Customer satisfaction is the key to a successful business. It is providing the best experience for the customers when they interact with your brand, so that they keep coming back for more. In an increasingly demanding market, organizations continue to invest in QA/Testing to improve customer satisfaction and delight.
Sometimes, us testers may consciously or unconsciously focus too much on finding issues or testing the functionality, that we fail to see the bigger picture- what our customers feel about our products and the usefulness of features that we are rolling out. To deliver a top-class customer experience testers should think about more than just about finding bugs 🐞
Take a look at this checklist:
- Are you a tester who wants to do more than just finding and reporting bugs?
- Are you looking to add more value to the software development process?
- Are you thinking about how you can prevent bugs that can bother customers?
- Are you willing to go that extra mile for your users, to deliver the best customer experience?
If the answer to these questions is yes, you should continue reading…📖
Anything That Can Go Wrong Will Go Wrong
“No user would do that!” – a classic reply that testers get from their developers/product managers when they find a so-called ‘edge case’. Several bugs get pushed to the backlog with the same explanation. However, they gain significance and turn to a high-priority bug when customer’s report them. Quality is subjective. No matter how the developers or stakeholders feel about the software, it’s the customer’s opinion that really matters. Anything that can go wrong will go wrong. Users are easily distracted from the task at hand. The users of your software will always make mistakes, wherever it is possible. Users have high expectations from the software products they use. With easy access to hundreds of alternatives in the market, a frustrated user will churn and share his bad experiences publicly causing damage to your brand reputation 😣
Additionally, the cost of finding and fixing defects in software increases exponentially with time. Mistakes that are being made (by developers, testers, or customers) lead to a defect in the software. Can we build software in such a way that we can prevent defects from happening in the first place rather than fixing them later? 🤔
Here enters “Poka-Yoke”.
What Is Poka-Yoke?
Poka-yoke is a Japanese term for “mistake-proofing”. The term ‘Poka-yoke’ was coined by Shigeo Shingo, a leading expert on manufacturing practices at Toyota, Japan. Poka-yoke is a technique that makes it impossible to make mistakes leading to improved quality and reliability. The objective of Poka-yoke is to prevent defects by finding and eliminating mistakes at the source.
Electric appliances that we use every day have poka-yoke features that make them safe and convenient. You cannot start your household appliances like washing machines or microwave ovens until the door is closed. And while the machines are operating, the door is locked to avoid risks involved in machines running with an open door. Therefore, there is no way that the user can start these machines without closing the doors, preventing any human errors ❌
All the modern-day cables and connectors fit only into their respective slots with precision to prevent users from connecting the wrong cables in the wrong places. Poka-yoke in these plugs ensures that only one way of plugging in is possible. Is mistake-proofing only used in manufacturing? Not really, a lot of software development processes, practices, and ideas have derived from the manufacturing industry.
Poka-Yoke in Software Design
The cost of a mistyped account number is very high in a banking application and requires an error-proofing mechanism. Banking applications hence implement Poka-Yoke in software design to prevent users from making costly mistakes. For example – when adding a payee or transferring money you are asked to type the payee account number twice 🔐
The intention is to eliminate the risk of transferring the amount to an incorrect user/account number. Most of the banking applications mask the text entered in the ‘Account number field. This forces the user to type the account number again without referring to what is entered earlier. This feature prevents users from retyping an incorrect account number twice. Additionally, most banking accounts disable copy/paste in these fields to strengthen error-proofing.
Many social media applications prompt you to type ‘DELETE’ to confirm the destructive action of deleting your accounts. Again, this is a good example of error-proofing as it is impossible to type ‘DELETE’ by accident. This ensures that users do not lose their data by a press of a button.
Remember to implement poka-yoke pragmatically. Mistake proofing should not come at the cost of a reduced user experience 😊
Adopt A Poka-Yoke Mindset While Testing
Just like how Quality is not just a tester’s responsibility, it’s not just the UX designer’s responsibility to ensure a good user experience. Delivering a good user experience is the responsibility of the whole team. As a tester, you should adopt a poka-yoke mindset and advocate for error-prevention mechanisms wherever possible. For instance, assume that you are testing a basic file uploader: 📂
Fig 1 – A simple file uploader
You learn that there are no instructions about the supported file types in the UI when exploring the application. When you choose a file and click on the ‘upload’ button, you discover that the file type is not supported. This may seem like perfectly fine behavior, but can we inform the user about this detail a little earlier?
Fig 2- You discover that they can only upload certain file types
As a tester, you can suggest an improvement to clearly specify the file types supported. This will improve the user experience to a certain extent. Moreover, the users will learn about the supported file types one step earlier 🏃♂️
Fig 3- Instructions added specifying the supported file
A thoughtful design is much better than a good error message, which prevents a problem from occurring in the first place. Modern-day users often suffer from information overload and may not always observe or read everything on the screen. As a customer-obsessed tester, along with this improvement, you can suggest a poka-yoke approach. In addition, think about how an error can be prevented instead of recovering from it. Build the feature in such a way that only the supported file types can be selected from the file uploader.
File uploader restricting the selection of unsupported file types
This will prevent users from choosing an unsupported file type. Poka-yoke should safeguard your users from doing mistakes. It should enable them to accomplish their tasks faster and without any frustrations 💪
Let us look at another simple example. I was trying to download one of my youtube videos. A youtube video downloader lets you download videos from youtube to your device. All you need to do is copy the link of the desired youtube video into the URL field and click on the “download” button. The first application (Application 1) I used to download a video did not seem to do the job it claimed. When I pasted a proper youtube video link, it failed with an error message – “Unkown error occurred. Please check the URL and try again”. I pasted the same URL in the browser and the link opened up the video. The error message was not of much help to me.
I was unhappy with application 1. I tried application 2 and attempted to download the video again. When I tried the same URL in Application 2 it worked flawlessly. Later I realized that I had missed adding ‘https://’ in the URL. Application 1 was not auto-correcting my mistake. Auto-correcting common errors enhances the user experience of your applications. Application 2 automatically added ‘https://’ in the URL even if the user omitted it. Most of the web browsers we use today also implement this poka-yoke approach.
These enhancements may seem to many like a very small thing. Small things make a big difference. Paying attention to the minutest of details matters to create a world-class user experience. Every small mistake that you can anticipate and prevent, will add value for your customers. There are several examples of how small changes lead to huge conversions and a significant increase in revenue for the business 🔥
Poka-Yoke is an attitude, it’s a mindset, that every tester (and in fact everyone in your team) should adopt. To build great software, you should be empathic to the users whom you serve. Finding bugs is not the only objective of testing. Preventing bugs and ensuring that the software product meets the user’s expectations are equally important. In this article, we have discussed applying Poka-Yoke in software design. However, you can apply the Poka-Yoke technique wherever a mistake can occur. Think about the ways we can build our code, tests, systems, practices, processes in such a way that mistakes cannot be made 🙏