Turn your manual testers into automation experts! Request a DemoStart testRigor Free

Essential QA Metrics to Improve Your Software Testing

QA Metrics

– Introduction

QA stands for Quality Assurance, an essential part of SDLC (Software Development Life Cycle) – defines processes employed to discover defects as early as possible, as well as to minimize the chances of defect occurrences in the future. On the other hand, quality assurance metrics are parameters or indicators that we can track to measure the overall testing process and product quality.

Tracking these indicators is crucial from every stakeholder perspective, the product manager, team lead, or the QA person.

  • Team leads can track them to get a hold of their team’s productivity.
  • Product managers can do a better job of estimating project completion dates.
  • Testers can improve their test coverage and efficiency.

Good QA metrics must be measurable, insightful, and notably aligned with the business goals.

Types of QA Metrics

Mainly, there are two types – Base Metrics and Calculated Metrics.

Base or Absolute Metrics

They encompass measurements or data points collected during test case development and execution for tracking your project.

Examples include:
  • The number of test cases planned/executed.
  • The number of test cases passed/failed.
  • The number of defects found/fixed – (categorized as critical, high, medium, and low severity).
  • Execution time it took to run these tests.

Calculated or Derived Metrics

Calculated metrics enable us to estimate the effectiveness of the testing process and the quality of the product. QA leads apply specific metric formulas over previously collected base points to get insights into the efficiency of their team as well as the whole development process.

They are further classified into two more categories – Process metrics and Product metrics.

Process Metrics

These metrics help us to get track of the whole testing process.

Process metrics include:

1. Test tracking metrics – the percentage of test cases passed/failed. That way, we can estimate the amount of work done/needs to be done.
(Number of passed (or failed) tests / Total number of tests)*100
In the image above, there are a total of 8 features, out of which 5 passed.
Thus, Pass % is (5/8)*100 = 62.5%
Fail % is (3/8)*100 = 37.5%
2. Test Case Execution Productivity – estimates the timing of the test cases execution (per hour). Therefore, enabling us to have the information of the team’s bandwidth to perform these tasks.
(Number of test cases / Time spent for test case execution)
200 test cases, 20 hours total time spent
Thus, team productivity is (200/20) = 10 test cases/hour
3. Test Design Coverage – this coverage is used to measure the percentage of requirements or user stories covered by the test cases.
(Number of requirements mapped to test cases / Total number of requirements)*100
Let’s say there are 110 user stories, and only 20 of them are mapped to test cases.
Thus, design coverage is (20/110)*100 = 18%
4. Test Execution Coverage – helps to track the progress of test activities by comparing the number of planned and executed tests.
(Number of test cases executed / Total test cases planned)*100
Let’s say there are 110 test cases planned at the beginning of the testing process, but only 80 of them were executed before the product’s first release.
Thus, execution coverage is (80/110)*100 = 73%

Product Metrics

Product metrics, as the name suggests, measure the product effectiveness and are used at later stages of the Software Testing Life Cycle during the defect analysis. It helps us to get a better understanding of software’s behavior under test.

Product metrics include:

1. Error Discovery – shows the effectiveness of the test cases in percentage.
(Number of defects found / Total number of test cases executed)*100
Out of 110 test cases executed, there were 14 defects found.
Thus, error discovery % is (14/100)*100 = 13%
2. Mean Time to Detect – MTTD, refers to the amount of time it takes for a testing team to detect issues/bugs.
(Number of defects found / Execution time)
4 defects/issues found in 2 hours
Thus, MTTD is (4/2) = 2 defects/hour
3. Defect Density – can be referred to as the number of confirmed defects/bugs found per the software size. Software size could be measured by the number of lines of code or the number of requirements or user stories.
(Number of defects found / Total number of requirements)
4. Defect Severity – the defect severity index is used to get an estimate of the overall criticality of the software that needs QA attention. There are various severity levels, each one being assigned a coefficient.
Critical defects — Coefficient = 8
High-severity defects — Coefficient = 6
Medium-severity defects — Coefficient = 3
Low-severity defects — Coefficient = 1
{(Number of critical defects * 8) + (Number of high-severity defects * 6) + (Number of medium-severity defects * 3) + (Number of low-severity defects * 1)} /
Total defects

Metrics – Which ones to choose and Why?

Ensuring fewer bugs/defects in production requires a better QA approach, which in turn calls for choosing the right metrics.

So, a set of key performance indicators (KPI) that product owners could choose for their testing teams are as follows:

Mean Time To Detect (MTTD) – the time it takes for a QA team to detect any defect in the product, tops the list of our KPIs, because the sooner we detect bugs, the sooner developers will be able to fix the issue.

Defect Summary – getting to know about all kinds of defects, their nature, and their severity can help QA teams to improve product quality. This includes getting information regarding open defects, reopened bugs, fixed bugs, defect density, etc. Having the list of critical severity bugs at hand can help us understand potential losses.

Test Coverage – coverage from a design or execution perspective. The number of prepared test cases, executed test cases (passed/failed tests) can help us monitor the relevance of our automation test suite. The team can then decide to improve on remaining test cases by keeping the same strategy or changing to a different one.

Reading test velocity graph – by measuring the number of tests executed over a time period can help us estimate the pace of automation, which can further help in proper resource allocation, timely delivery, and increase in individual-level bandwidth.

Above were the suggested KPIs that a software team might want to choose to attain productivity, but businesses with different objectives and key results (OKR) choose various KPIs which best suit their goals.

We hope this article will help you on your journey of building a better QA process within your organization. And should you be also interested in finding the best end-to-end UI codeless automation testing tool on the market, you know where to find us.