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

Software Development is dedicated to crafting superior software utilizing a systematic and well-organized method.

The subject area contains several best practices that comply with set standards meant to produce a top-quality final product. Analysis, Design, and Implementation are the core phases of the software development workflow. In order to achieve excellent software quality, it is paramount to provide a defect-free finished product.

Software Process Engineering

Manage Defects

A defect is an unexpected or undesirable behavior exhibited by the software. The process of managing defects is ongoing rather than a solitary event.

Identifying and fixing defects in the earlier stages of software development greatly lowers time, rework, and costs. Fixing defects later in the development cycle is significantly more costly than addressing them in the earlier stages. The quality of the software gets improved by focusing on reliability, portability, maintainability, among others.

So, it is recommended for every firm to establish a strong defect management system and have a dedicated team to manage defects at every step of the development process, thus ensuring top-quality products that win customer trust.

POKA-YOKE is an efficient technique for preventing errors.

Defining Poka-Yoke

Poka-Yoke is a quality assurance technique pioneered by Shigeo Shingo, a renowned Japanese engineer. It’s a combination of two Japanese words, “poka” meaning “error” and “yoke” meaning “avoid”, so it roughly translates into “error avoidance” or “error-preventing” strategy.

The main goal of Poka-Yoke is to reduce defects by preventing or correcting mistakes early in the design and development process. Though primarily used in manufacturing industries, it has also seen successful implementation in software development processes.

An Applied Example of Poka-Yoke from Manufacturing

An excellent instance of Poka-Yoke design from manufacturing is the SIM card slots in mobile phones. They’re designed in a specific manner, making it possible to correctly insert the SIM card. This design leaves no room for users making an error while inserting a SIM card into their mobile phone, making it virtually error-proof.

A Real-Life Poka-Yoke Illustration in a Software Application

A good illustration of a Poka-Yoke process in a software application is seen in the Gmail email attachments feature. When drafting a new email, if you include the words “find attached” but forget to attach any files, Google presents a pop-up reminder querying if you still wish to send the email. This preemptive alert ensures users don’t send an email without the intended attachments.

How does the Poka-Yoke Method Operate?

Steps to Incorporate the Poka-Yoke Technique:

Here are several steps to plan and incorporate a strategy to prevent software defects:

• Document all user scenarios and end-to-end test cases for the specific application.
• Probe these user situations using the 5-whys questioning strategy to grasp potential failure points.
• Once potential failure points are determined, plan and implement a Poka-Yoke strategy to tackle these problems. For instance, a simple unit test could be implemented to verify a certain function’s functionality.
• Ensure the strategy is crafted to prevent defects by delivering error messages or warnings for improper inputs or misuse of user situations.
• After the Poka-Yoke Strategy has passed the trial successfully, include it in the list of processes to be conducted during each fresh release/build. For example, in unit testing, once a unit test is developed to verify the functionality of code, it should be performed whenever relevant modules are updated.
• Evaluate the success of the Poka-Yoke technique by gauging its capacity to prevent or identify defects during occurrence.

Poka-Yoke Classifications

• Defect Prevention
• Defect Identification

Defect Prevention is a key activity within the Software Development Lifecycle (SDLC). This approach involves pinpointing potential problems and taking proactive measures to eliminate them. Many software defects can be avoided during the design phase.

The role of the Quality Assurance team is crucial in defect prevention, where they review the Software Requirement Specification (SRS) documents. Any issues identified at this juncture should be addressed during the coding phase of software to prevent them from escalating to later stages.

The given examples from the manufacturing and software industry demonstrate the effectiveness of defect prevention techniques.

Defect Identification is a routine assignment for quality assurance teams. QA teams utilize various strategies and methods to execute test cases effectively. They identify defects through diverse testing methods such as Smoke and Exploratory testing.

Attributes of a Robust Poka-Yoke Process

• An effective Poka-Yoke process should be easy to develop and maintain. It should be user-friendly and affordable. Having a complex Poka-Yoke strategy might be time-consuming and result in potential issues if not maintained properly.
• Poka-Yoke should be contrived early in the SDLC to quickly pinpoint issues.
• An effective Poka-Yoke process should correctly identify and address issues as they arise.
• Poka-Yoke should be crafted in such a way that it efficiently counters most prevalent issues in the software.
• It should be integral to the software design and coding procedure.

The Critical Role of Poka-Yoke in the Software Design Phase

To produce superior quality software, it must be designed in a way that lives up to user expectations. Users should find the software easy to maneuver without committing costly errors.

Poka-Yoke Instances in Design and Quality

#1) When drafting an email using Gmail, users may fail to attach files. Gmail will prompt an alert reminding users to attach files if the words “find attached” were included in the email. This is a practical example of Poka-Yoke in action.

#2) Many websites offer a password strength guide to assist users in creating a strong password using a blend of characters and digits.

#3) The Google search engine provides spell correction suggestions for users, helping them avoid unintentional mistakes.

#4) Banking websites often employ a double text field for sensitive information such as passwords or account numbers. The second text field is typically encrypted to prevent user errors in input values and ensure a match between the two text field values.

The Importance of Poka-Yoke in Software Development

Numerous industry examples have shown that the cost to fix a defect after a product’s release is significantly higher than if it were rectified during the development cycle.

More on this topic =>> Understanding the Cost of Quality (COQ)

The optimal way to avert issues after the release is to incorporate mistake-proofing techniques like Poka-Yoke that can identify defects early in the development phases, thus curbing the cost of remedying them. The effectiveness of the Poka-Yoke method heavily relies on the tester’s ability to unearth and resolve potential issues.

Poka-Yoke Instances in Software Development

1. Unit testing robustly boosts mistake-proofing in software development.
2. Implementing validation mechanisms is always a good practice for developers. Issues related to validation should be addressed in the code to effectively manage errors. It’s also crucial to regularly review and update these validation measures.
3. Employing skilled professionals is a common and highly effective Poka-Yoke technique in ensuring software excellence.

To Summarize

While making errors is a part of life, persistently repeating the same errors is not advisable. In order to avoid repeating the same mistakes, checks or procedures must be put in place. To combat this problem, the Poka-Yoke techniques have been devised.

References Featured in this Article:

• Zero Quality Control by Shigeo Shingo
• Poka-Yoke Wikipedia entry
• Software Testing Techniques, 2nd ed. Van Nostrand Reinhold by Boris Beizer

About the Contributor: This guest post was penned by Nataraj Kanchyani, an experienced Software Engineer-Testing at Centurylink Technologies India Pvt Ltd, based in Bangalore.

---

If you have experience working with the Poka-Yoke technique or if you’ve developed defect prevention and identification procedures from your experiences, feel free to share your thoughts in the comments section.