Mistake-Proofing – the Poka-Yoke of Usability [transcript]

How do we go about mistake-proofing our product design? There’s a checklist we can use, based on a well-known manufacturing production method, poka-yoke. Let’s talk about poka-yoke for product design, after this brief introduction. 

Hello and welcome to quality during design, the place to use quality thinking to create products others love, for less. My name is Dianna. I’m a senior level quality professional and engineer with over 20 years of experience in manufacturing and design. Listen in and then join the conversation at QualityDuringDesign.com.  

We can evaluate our product design concept with a user process analysis. We can use a process flowchart to detail the steps our users need to take with our product to achieve a result. Knowing our typical users and the environment in which they’ll be using our product, our team can examine the process flow map and find areas where mistakes are likely to happen. This is great to do early in the concept phase because it helps us with design features. We can continue to develop the flowchart throughout the product development process, getting more specific with the steps and the mistakes as we get more clarity about what components are part of our design.

Features that are designed-in to our product to stop user mistakes from happening are a type of preventive control. Features designed-in to help identify that a user mistake has happened is a type of detection control. Preventive controls are best because they help us avoid the error altogether. If we can’t prevent the error but still need to either ensure it doesn’t happen or it gets fixed quickly if it does happen, then we start using detection controls. To help us decide on what type of controls we can and want to use for our product design, we can step through some choices by using a standard Quality tool from manufacturing: poka-yoke, or mistake-proofing.

Shigeo Shingo was a Japanese industrial engineer who was part of the acclaimed Toyota Production System, a management system. He’s credited with coining “poka-yoke” in the early 1960s. Poka-yoke is a Japanese term meaning “mistake-proof”. It started out as “baka-yoke” which translates to “idiot proof”. The story goes that people were evaluating a production process on the floor, during production. An operator overheard then taking about baka-yoke and burst into tears, crying “I’m not an idiot!” The name was afterwards changed to mean mistake-proof, or “poka-yoke”. Besides avoiding hurt feelings, poka-yoke is focused on activities and NOT the person, anyway, Really, we’re addressing the root cause of an error. “People” are not root causes of issues. There’s always another root cause either before or after “a person made this mistake”, something we can act against to correct the issue.

The poka-yoke mistake-proofing philosophy is part of lean and six sigma methods. We’re either making a mistake easily noticed or preventing it from happening in the first place. There are two cornerstones of this method: it should be easy to the point that it’s almost obvious after we’ve done it (a type of thing where we ask ourselves, “why weren’t we doing this already?”). And it’s close to the point when the error was made…it either prevents a mistake or lets us know about the mistake soon after it happens. If caught immediately, the error can be corrected right away to avoid further issues. This has a lot of benefits. We learn from our mistakes, so it helps prevent a reoccurrence of the same issue. It helps to identify the source or cause of the error when we’re notified quickly that it has happened. It can also save costs, headaches, and other bad things because we fix an issue right away, we’re not building out from the mistake, realizing it much later, and then having to do a lot of reworks to fix it.

Poka-yoke is typically an industrial engineering, manufacturing, and production method. But, poka-yoke can be applied to the user process, too. Mistake proofing the user process with the product design can help to avoid injuries and disappointing product performance. Whenever people can make a mistake with our product, that could be an opportunity to mistake-proof it with the design.

If we have a detailed flow chart of the user’s process (the steps they take to use our product) we can examine where human errors are likely to happen. Then, we find the source of the error, or its root cause. It’s likely to be within that process step, or one that is before it. For each error, we think of ways we can mistake-proof it. What can we change about the step where the error occurs? Can we make it easier to perform the step as desired and at the same time harder to create an error? Can we do the step differently, or replace it with a different type of action? Or can we eliminate the step altogether? Can we perform checks to ensure certain conditions are right before the process step can get started, like an automatic or designed-in measure?

If we can’t prevent mistakes from happening with the way the product is designed, what can we do to easily detect it? We can think of mistake proofing as inspections by the users. There are three dimensions of mistake proofing. One dimension of inspection is a combined who and when an inspection occurs. A second dimension is the way the inspection is performed. And the third dimension is about how the inspector (our user) is notified that there’s an error.

First, let’s talk about who or when an inspection occurs for an error.

  • source inspection checks are those that are done before the next process step. They’re usually automatic and prevent the user from completing a process step if the conditions are not correct. Source inspection checks could be designed-in, preventive measures.
  • self-inspection is done by the person who is using the product. The inspection is performed immediately after they’ve completed a step, after-the-fact. This allows for detecting if an error has occurred immediately after when it could have happened, so the user might have a good chance of correcting the issue before it turns bad or tragic.
  • successive inspections are performed by the next user of the process. It might be a good time to do this type of inspection if there’s a hand-off or transfer immediately after a process step.

The second dimension of poka-yoke is the way things are inspected, the methods.

  • physical method uses physical design features or characteristics to reduce errors.
  • step-sequence method checks the sequence of steps to ensure the right things happen in the correct order.
  • the grouping and counting method counts or measures parts to ensure the step is complete.
  • information enhancements method provides information to the user, so it’s available and perceivable when and where it’s needed.

The third dimension is signals, sometimes referred to as regulatory functions.

  • warning functions: are alarms, bells, whistles, and flashing lights.
  • control functions: prevent the user from proceeding in the process until the error is corrected.

Let’s talk about some examples from our everyday use.

[see the podcast blog write-up for a summary table]

As you can begin to see, there are a lot of mistake proofing examples in the designs we use every day. Leave me a comment in the podcast blog about another one you’ve noticed.

What are our insights to action today? Even if we cannot design-out all user mistakes with our product, there are probably things we can do to design-in poka-yoke inspections. They’re easier to notice and plan for if we have a user process flowchart. Waiting for the user process to be all done before we look for use errors is too late in the design process, so we’re going to do it early and iteratively as our design concept gets defined. We make mistake proofing methods easy (nearly obvious) and close to the point the error was made. To help us apply poka-yoke to the user process, we can look at it from 3 standard dimensions: who and when an inspection occurs, the method of inspection, and if there are signals or built-in controls.

If you visit QualityDuringDesign.com, at this podcast blog you’ll see an offer for a free mistake proofing checklist. You can print it out and have it handy when you’re deciding how to mistake-proof the user process for your design.

If this episode was useful, there’s a previous episode of Quality during Design that you might find helpful: Episode 29: Types of Design Analyses possible with User Process Flowcharts reviews the process flowcharting method.

Please go to my website at QualityDuringDesign.com. You can visit me there, and it also has a catalog of resources, including all the podcasts and their transcripts. Use the subscribe forms to join the weekly newsletter, where I share more insights and links. In your podcast app, make sure you subscribe or follow Quality During Design to get all the episodes and get notified when new ones are posted. This has been a production of Deeney Enterprises. Thanks for listening!