QA metrics are numbers that tell you how well your testing is working and how good the software is. Used well, they show where to focus, whether quality is improving and when it is safe to release. Used badly, they reward the wrong behaviour. This article defines the twelve metrics most teams need, gives the formula for each, and explains what the number can and cannot tell you. For how to put metrics into practice, report them and set targets, read our companion guide on quality assurance metrics.
Table of Contents
ToggleCoverage metrics: how much did we test?
1. Test coverage
Test coverage measures how much of the code or the requirements your tests exercise. Three common forms are code coverage (lines, branches or functions run by tests), requirements coverage and functional coverage.
Requirements coverage = requirements with at least one test / total requirements x 100
High coverage shows there are few untested areas. It does not show the tests are good, since a test can run a line of code and check nothing. Treat coverage as a way to find gaps, not as proof of quality.
2. Test execution rate
Execution rate = test cases executed / test cases planned x 100
It tracks progress through a test cycle and warns you early if the plan will not finish on time.
3. Test pass rate
Pass rate = test cases passed / test cases executed x 100
A falling pass rate on a stable area points to regressions. A pass rate that is always near 100 percent can mean the tests are too weak to find anything.
Defect metrics: what did we find, and what did we miss?
4. Defect density
Defect density = defects found / size of the software
Size is usually thousands of lines of code (KLOC) or function points. It helps compare modules and spot the riskiest areas. Use the same unit every time, and compare like with like.
5. Defect distribution
Count defects by module, severity, cause or phase. A pattern, such as most defects coming from one component, tells you where to put review and test effort. See defect triage for how severity is set.
6. Defect detection percentage (DDP)
This is the standard measure of test effectiveness.
DDP = defects found by testing / (defects found by testing + defects found after release) x 100
Example: testing finds 90 defects and customers report 10 more, so DDP is 90 percent. Because it needs post release data, it is a lagging figure, but it is one of the most honest.
7. Defect leakage
Defect leakage = defects found after release / total defects x 100
It is the mirror of DDP. Track the severity of leaked defects too, since one critical leak matters more than ten cosmetic ones.
8. Defect age and resolution time
Defect age is how long a defect has been open. Mean time to resolve (MTTR) is the average time from report to fix. Long ages mean a bottleneck in triage, fixing or retesting.
Efficiency and effort metrics
9. Test effort and productivity
Measure the hours spent on test design, execution and maintenance, and compare against output such as tests executed per person day. Use it to plan, never to rank individuals.
10. Cost metrics
Track cost per test, cost per defect found and cost of fixing defects at each stage. The broader view is covered in cost of quality. Defects found late cost much more than defects found early, which is the case for shifting testing left.
Automation and reliability metrics
11. Automation coverage and flaky test rate
Automation coverage = automated test cases / total test cases x 100
Flaky rate = tests with inconsistent results / total automated tests x 100
Coverage tells you how much you have automated. The flaky rate tells you whether you can trust the suite. A high flaky rate destroys confidence, so fix it before adding more tests.
12. Mean time to detect (MTTD)
MTTD is the average time between a defect being introduced and being found. A high MTTD suggests defects live too long before testing catches them. This is why early testing and continuous integration matter.
Agile and delivery metrics
Velocity and burn down charts describe team delivery, not test quality, so use them with care. Metrics that fit agile testing well include escaped defects per sprint, the share of stories with automated tests, and the time from commit to test result. Never use any metric to judge individuals, because people then change their behaviour to improve the number.
Avoid misleading metrics
- Test case count: more tests are not better tests.
- Bugs found per tester: it rewards logging trivial issues and punishes thorough prevention.
- 100 percent coverage as a goal: teams then write tests that touch code but check nothing.
- A single number: use a small set that balances coverage, defects and speed.
How to choose your metrics
- Start from a question, such as “can we release?” or “where do bugs come from?”.
- Pick three to six metrics that answer it.
- Define each one exactly, including the formula and data source.
- Track trends over time, not single readings.
- Review and retire metrics that no longer drive decisions.
For tools and dashboards, TestRail’s guide to test metrics is a useful reference. For turning these numbers into process improvements, see how to manage software testing defects and what quality assurance really means.
Conclusion
The best QA metrics are few, clearly defined and tied to decisions. Coverage shows what you tested, defect metrics show what you found and missed, and automation metrics show whether you can trust your safety net. Measure the process to improve it, and never to blame people.
Go deeper on QA Metrics. Related articles:
Want more testing guides in your Google results? Add Testmetry as a preferred source.




