How to Use Poka-Yoke (Mistake Proofing) Technique to Improve Software Quality

Software Process Engineering
Software Engineering is a discipline that aims at producing high quality software through systematic, well planned approach of software development. It contains many good practices, following the standards to achieve quality product. The three main phases of Software Development are, Analysis – Design – Implementation. To accomplish high quality software it essential to produce defect free product.

Defect is the unexpected or undesired behavior that occurs in the product. Anything related to defect is a continual process not a particular state.

Defect Management
Finding and fixing the defect in early stage of the software development reduces time, rework and money. Finding the defect in later stages always costs multiple times than early stages. It enhances the quality by adding reliability, portability, maintainability etc. Hence it is advisable every company should go with defect management system and defect management team at every stage of the development to attain the good quality in products and to gain the customer confidence.

One of such mistake proofing technique is POKA-YOKE,

What is Poka-Yoke?

It’s a quality assurance process introduced by Japanese engineer Shigeo Shingo. This term is used in Japanese language as “Poka” meaning mistake and “Yoke” meaning prevent i.e. mistake preventing or mistake proofing technique.

The purpose of Poka-Yoke is to develop processes to reduce defects by avoiding or correcting (design to show alerts or warning messages to user) mistakes in early design and development phases. This technique is mostly used in manufacturing industries but now this effective technique is also adapted in software development processes as well.

Poka-Yoke example from manufacturing industry

A good example of Poka-Yoke design from manufacturing industry – SIM card slot in cell phones is designed in such a way that user is allowed to insert SIM card in correct way only. There is no chance for user to make a mistake while putting SIM card in a cell phone. This makes the design mistake proof.

Poka-Yoke example from software application

The perfect example of Poka-yoke process in software application is – Gmail email attachments feature – when you type word ‘find attached’ while composing a new email and try to send it without attaching a file Google will show you a popup reminder saying that you used words “find attached” in your email but did not attach any files, do you still want to continue sending?

How Poka Yoke Technique Works?

Steps to Implement a Poka Yoke Process:
Below are few steps to design and implement a process to prevent software defects:

List all user scenarios or end-to-end test cases for the application.

Analyze all these user scenarios by asking 5-whys questions to understand the ways these scenarios can fail.

Once you identify the ways these user scenarios can be wrong, design and apply a Poka Yoke technique to avoid the possible problems (e.g. this design could be a simple unit test to check if any function written is working properly or not).

Make sure the technique designed to avoid the defect is working properly by giving errors or warning message for incorrect input or handing of the user scenario.

Once the trial is passed add this technique in the list of Poka Yoke processes to be performed each time on new release/build. (In above unit testing example, once the unit test is written to check the function code, check if it is working for positive and negative values. When this test passes add it to ‘unit tests’ repository to be executed each time any change is made in relevant modules)

Measure the success of this Poka Yoke process. Check if this technique has really prevented or caught defects when happening.

Categories of Poka-Yoke

Defect Prevention

Defect Detection

Defect prevention is most important activity in SDLC. This method is used to identify all possible issues and actions needed to eliminate those issues. Many software defects can be prevented in design phase itself. Quality assurance team can help to prevent these defects by reviewing the software requirement specification documents. All issues identified in this stage are addressed in software coding phase and prevented from carrying to later stages. The manufacturing and software industry examples provided above are the good examples of defect prevention technique.

Defect detection is most common task for quality assurance teams. QA teams use various approaches and strategies for executing test cases effectively. Defects are detected by many other testing methods like smoke and exploratory testing.

------------

What are the Qualities of a Good Poka-Yoke Process?

Poka-Yoke should be simple to create and maintain. It should be easy to handle and cost-effective. Maintaining a complex Poka-Yoke is time consuming and often results in issues if not maintained properly.

Poka-Yoke should be designed early in SDLC so that it can detect issues quickly.

A good Poka-Yoke should be accurate enough to find the issues when they occur.

A good Poka-Yoke should be designed in such a way that it should stop most common issues occurring in the software.

It should be part of software design and coding process.

Need of Poka-Yoke in Software Design Phase

To develop quality software, it is important to design it according to user’s expectations. User should be able to use/handle the software with ease without making any costly mistake.

Poka-Yoke examples in design and quality

1) The example of missing attachment file while composing email using Gmail.

2) Some websites show password strength indicator to show password strength. It also guides users to use strong password with combinations of characters and numbers.

4) Banking websites use double text field feature to accept sensitive information like passwords or account numbers. The second text field is usually encrypted to avoid making any mistake while providing the input value and to check if both the text field values match.

Need of Poka-Yoke in Software Development

From countless industry examples it’s now well known that cost of fixing a defect after product release is many times greater than fixing it in development cycle. Best solution to avoid post-release issues is introducing the Poka-Yoke techniques which could catch defects in early development phases making it cheaper to fix. Poka-Yoke process implementation largely depends on tester’s ability to capture and eliminate the issues.

Poka-Yoke examples in Software Development

Unit testing is one of the most effective means of mistake proofing software development.

Having validation Poka-Yoke in kit is always a good suggestion for developers. Validation mistakes should be handled in your code. These validation issues should be revisited and updated periodically.

A common and most effective Poka-Yoke is to hire right candidates to mistake proof your software.

Conclusion:

Making mistakes is OK; just don’t make the same mistake again and again. And to avoid making same mistakes again there should be some checks or processes in place. The Poka-Yoke techniques are developed to solve this problem.

The Best Software Testing Training You'll Ever Get!

17 comments ↓

FMEA (Failure Mode Effect Analysis) is also one of the technique used to identify the risks and mitigate them in the Design.
How this Poka-Yoke is the difference from FMEA?
Is it an another techinical term for FMEA?

@BasavaKumar M,
FMEA – is a evaluation method for possible failures and impacts on system.Does this method contains possible preventive methods ? Not sure ..
Poka-Yoke – It is a preventive system before failure.In very early stage we try to stop major issue.
Ex: Now your login page handles 10 possible failures, later if you find/learn more preventive methods,then you need update poke-yoke to address these issues as well.
But intension of both technique is same,that is to provide quality product.

Good one.I dint heard about this term before and thanks for keeping the information in it,in a very simple and straight-forward way.This article will be a good guide to understand about different software testing techniques in the industry for the freshers like me.

@ Shanudeen
there are very nice and simple examples given in this post itself. for example the example of mistake proofing gmail feature to send email without attachment. Most users draft emails with words like attachments but they forget to attach the files. If they get popup message like Google gives user will not make any mistake using the application.

this is the example of poka yoke in design phase wheer Google reduced the possibility of issues by desiging the application in such a way that most issues occuring while handling the application are already anticipated and taken care by design.

Hi Nataraj,
Great Information!
I really more enjoyed read this article.
At ITCombine we believe in providing with cost effective solutions for combining technology with business goals. ITCombine can boast of expertise in providing diversified services at one place, with high proficiency.

Hi Nataraj,
It is a nice article. But i need to know if we can use Poka-Yoke in a Validation testing which is predominant while dealing with Software’s used by Life Sciences industry where restrictions on the type of testing are quite a lot.