In order to have better view of the quality of defects, instead of measure using numbers of defects (which can be manipulated), can I measure the % of root cause. Example codes problems, missing use cases, missing test cases? Please share your experiences and thoughts.

4 Answers 4


In functional testing services, software testers report bugs every day. It's important to understand in which category the bug belongs. Bugs can be caused by many factors, including: Unclear requirements Poor communication during development Frequent changes to project requirements Bad coding practices Poorly documented code Compromises made to save time Lack of communication between team members Poor requirements, architecture, or design

Bugs can be categorized bugs by analyzing common patterns. These patterns can include:

  1. Code-related issues- Here are some common coding issues: Repetitive code Bad variable names Not using comments Language overload Not backing up code Complicated code Not asking questions Not planning in advance

  2. Missing use cases: A missing use case is a use case that lacks interaction information, which can indicate missing requirements. simple use case name may not sufficiently describe the use case details that affect the derived requirements

  3. Data-related issues: Data-related issues can arise at any stage of the data entry process, from data collection to data integration. Some data related issues include: a.Data quality issues: These include: b.Missing data: Can be caused by intentional or unintentional omissions c.Duplicate data: Can skew business intelligence d.Inaccurate data: Can be caused by human errors, such as misspelled names or wrong ZIP codes e.Ambiguous data: Can be caused by misleading column headings or undetected spelling errors f.Data governance: Poor data governance can lead to quality issues g.Data format issues: Data can come from diverse sources with different formats and structures h.Data security: More data means more opportunity for security breaches i.Inconsistent data: Can be caused by missing data or inefficient data management

4.Out of bound bugs - Out-of-bound bugs are a type of software bug that occurs when a user interacts with the software in an unintended manner. These bugs can happen when a user: Enters a value or parameter outside the limits of unintended use Makes logical and arithmetic errors that exceed the allowable boundaries of a specified operation Interacts with the software in a manner that is outside its logical capabilities

You can also classify bugs into multiple categories based on their nature and impact. These categories include:

  1. Functional bugs
  2. Logical bugs
  3. Workflow bugs
  4. Unit level bugs
  5. System-level integration bugs
  6. Security bugs
  7. Syntax errors

This is a great idea, but not new. I have seen RCA (Root Cause Analysis) being done in several places, not as a replacement to other processes but as complementary. Most test management tools should easily support such categorization and analysis.

Having said that, this is not an easy task especially if you want it to be properly done. Similar initiatives tend to start with deep investigation of each bug, e.g. by asking five whys, and slowly end as being ignored or a very shallow reason for the failure is chosen.

Finally think of what do you want and can achieve, many times you will find out the the reasons for bugs are organizational and not easy to fix, "missing test cases" is usually a symptom to over stressed development, miscommunication or non aligned development processes.


Although the idea of performing root cause analysis is sound, I have yet to see a good categorization scheme. In my experience, trying to categorize root causes tends to yield categories that are too broad to be meaningful and useful or categories that are so fine-grained that they tend to be difficult to put causes into.

So far, my preferred approach has been to track proposed preventative actions and keep track of the number of RCAs that have proposed a given preventative action. Of course, the action itself may have a different impact on various incidents, but understanding that carrying out a certain preventative action would have mitigated or prevented a specific number of incidents can help prioritize which preventative actions to implement.


With more than 10 years of QA experience and association with a software qa consulting firm, I can certainly say that tracking and classifying the root cause of issues is one of the most beneficial practices in software testing.

  • During reporting and investigation, we have been employing this strategy as a drop-down in the JIRA tickets.
  • The drop-down is pre-populated with different reasons for DEV team selection.
  • Sharing a screenshot for the same with different categorization values for the 'root cause' type.

RootCause Categorisaton

The tracking of the "root cause" of the issues gives us an understanding of the areas missed by the DEV team and improvements required in the development process.

  • exactly. the JIRA dropdown when closing a bug is optional to me. for instance, "Coding mistake" is too generic. I need for insight from developer on which component and area need to be careful handle. I just completed one session and it is very fruitful. at least I can see the rest of developers learnt from the problem maker, and aware of what to be caution in future. Commented Jul 19, 2023 at 8:49

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.