Share this
Software testing metrics - defect removal efficiency (DRE)
by John O'Brien on 18 July 2011
In my last post Essential testing metrics “Defect Removal Efficiency (DRE)” was identified as the most important measure of testing quality. Defect Removal Efficiency relates to the ability to remove defects introduced to a system by a project during the project life cycle.
At its simplest DRE can be expressed as a percentage where DRE = (total defects found during the project/total defects introduced by the project) x 100
How do we determine the total number of defects within a solution?
One of most significant challenges in calculating a DRE percentage is determining the total number of defects introduced to the system by the project, there are a number of ways how this can be determined –
- Defect Seeding – This is where defects are deliberately placed into code in order to determine the effectiveness of a testing programme. Defect Seeding has been used in a number of academic studies but is rarely used in real world testing where timeframes and budgets are often already stretched, creating representative defects is a difficult and time consuming activity.
The total number of defects in a application can be extrapolated to = total defects found during testing x (total defects seeded/total seeded defects detected)
- Defect Estimation – This involves estimating the number of defects within a system based on previous deliverables and industry experience. This is a technique that would be unlikely give a truly accurate defect count, and will be of more value as an input into the initial Test Planning estimates.
- Defect Counting – This involves combining the “number of defects found during testing” with the “number of defects identified in Production traced back to the project”. This method will always give a lower value than the true number of defects introduced by the project as –
- Not all defects manifest themselves as failures in Production
- Cosmetic and Usability related defects are often less likely to be raised in Production.
- In order for the DRE metrics to be useful they should be derived as close as possible to when the system exited test, however many functions may not be executed in Production until the system has been live for a number of years.
What I would recommend in most instances would be using “Defect Counting” and cutting off the Production Defect count after the system has been live for three months. This should be sufficient for the majority of significant issues to be identified, while still being providing the information within a relevant timeframe.
Normalising the defect data
In order to be effective it is important that defects are consistently raised and classified across the testing life cycle and production, this means –
- Ensuring that defect severities across test are applied according to the definitions specified in the test strategy
- If necessary reclassifying Production defect priorities to ensure that they are consistent with defects raised in test
- Analysing any Production Change Requests to see if they are actually addressing defects
- Often there can be a delay in raising Production defects so there is value is talking to some of the key System Users to identify any issues that they have observed but not yet formally logged.
Where were the defects introduced?
In order to measure the effectiveness of specific test teams or test phases it is necessary to determine where within the project life system defects were introduced, this requires a level of root cause analysis as to the likely cause of each defect. Defects are usually classified as being introduced in the following areas –
- Requirements
- Design
- Build
- Deployment to Production
For an iterative project it is also good practice to record the iteration in which the defects were introduced.
Where should defects be identified?
The V-model provides a good guide as to where within the Project Life cycle different classes of defects should be identified. I would normally apply the following criteria:
Defect introduced |
Defect characteristics |
Phase where defect should be identified |
Requirements Phase |
Requirements Related |
Requirements inspection |
Design Phase |
Design Related |
Design Inspection |
Build Phase |
Functional defect - within a code component or between related code components. |
Unit Test |
Build Phase |
Integration between components within an application |
Integration Test |
Build Phase |
Functional defects / standards / usability |
System Test |
Build Phase |
Non-Functional defects |
Non-Functional Test Phases |
Requirements and Design Phase |
Business process defects |
Acceptance Testing |
Deployment Defects |
n/a |
Post-Deployment Testing |
For an iterative project defects should be identified during the phase in which they were introduced.
Calculating DRE for specific Testing and Inspection Phases
A “phase specific calculation of DRE” can be documented as “total number of defects found during a particular phase / total of number of defects in the application at the start of the phase”.
Some basic rules that should be applied –
- Most projects are delivered in a iterative fashion
- A test phase can only find defects that are actually in the solution when executed
- A test phase for a particular iteration however should still consider defects introduced by previous phases (Unit Test is an exception to this rule as it is usually phase specific)
- The non-functional test phase should only be expected to find non-functional defects within their area of focus (obviously knowledgeable non-functional testers may find some functional defects, however this is not the prime purpose for their testing and should not count towards their DRE calculation)
- Functional test phases should not be expected to find non-functional defects.
- Functional test phases follow a solution maturity level as implied by the v-model; less mature test phases should not be expected to find defects belonging to higher phases (i.e. unit test would not be expected to find business process defects)
Example Formula
Phase Specific DRE
This measures how effective a test phase is at identifying defects that it is designed to capture
- DRE Requirements Inspection = (number of requirements related defects identified during requirements inspection/total number of requirements defects identified within the solution)
- DRE Design Inspection = (number of design and requirement related defects identified during design inspection/total number of design and requirement defects identified within the solution)
- DRE Unit Test = (number of unit test defects identified during unit test/total number of unit test defects identified within the solution)*
- DRE Integration Test = (number of integration defects identified during integration test/(total number of integration test defects identified within the solution post-unit test )
- DRE System Test = (number of system test defects identified during system test)/(total number of system test defects identified within the solution post-Integration test )
- DRE Acceptance Test = (number of acceptance test defects identified during acceptance test)/(total number of acceptance test defects identified within the solution post system test )
*As unit test is often an informally recorded testing activity this metric may not be able to be derived in which case other development quality metrics such as “defects/line of code” could be applied.
Overall DRE
This measures how effective a test phase is in capturing any residual defects within the application irrespective for the phase that should have caught them. (As an example Acceptance Testing is not specifically trying to find Unit Test defects, however a thorough testing programme will cover many paths through the functionality and should identify missed defects from other phases).
- Overall DRE System Test = (number of defects identified during system test)/(total number of functional defects identified within the solution post-Integration test)
- Overall DRE Acceptance Test = (number of defects identified during acceptance test)/(total number of functional defects identified within the solution post-system test)
What is a good DRE Score?
An average DRE score is usually around 85% across a full testing programme, however with a thorough and comprehensive requirements and design inspection process this can be expected to lift to around 95%.
Share this
- Agile Development (153)
- Software Development (126)
- Agile (76)
- Scrum (66)
- Application Lifecycle Management (50)
- Capability Development (47)
- Business Analysis (46)
- DevOps (43)
- IT Professional (42)
- Equinox IT News (41)
- Agile Transformation (38)
- IT Consulting (38)
- Knowledge Sharing (36)
- Lean Software Development (35)
- Requirements (35)
- Strategic Planning (35)
- Solution Architecture (34)
- Digital Disruption (32)
- IT Project (31)
- International Leaders (31)
- Digital Transformation (26)
- Project Management (26)
- Cloud (25)
- Azure DevOps (23)
- Coaching (23)
- IT Governance (23)
- System Performance (23)
- Change Management (20)
- Innovation (20)
- MIT Sloan CISR (15)
- Client Briefing Events (13)
- Architecture (12)
- Working from Home (12)
- IT Services (10)
- Data Visualisation (9)
- Kanban (9)
- People (9)
- Business Architecture (8)
- Communities of Practice (8)
- Continuous Integration (7)
- Business Case (4)
- Enterprise Analysis (4)
- Angular UIs (3)
- Business Rules (3)
- GitHub (3)
- Java Development (3)
- Lean Startup (3)
- Satir Change Model (3)
- API (2)
- Automation (2)
- Scaling (2)
- Security (2)
- Toggles (2)
- .Net Core (1)
- AI (1)
- Diversity (1)
- Testing (1)
- ✨ (1)
- August 2024 (1)
- February 2024 (3)
- January 2024 (1)
- September 2023 (2)
- July 2023 (3)
- August 2022 (4)
- August 2021 (1)
- July 2021 (1)
- June 2021 (1)
- May 2021 (1)
- March 2021 (1)
- February 2021 (2)
- November 2020 (2)
- September 2020 (1)
- July 2020 (1)
- June 2020 (3)
- May 2020 (3)
- April 2020 (2)
- March 2020 (8)
- February 2020 (1)
- November 2019 (1)
- August 2019 (1)
- July 2019 (2)
- June 2019 (2)
- April 2019 (3)
- March 2019 (2)
- February 2019 (1)
- December 2018 (3)
- November 2018 (3)
- October 2018 (3)
- September 2018 (1)
- August 2018 (4)
- July 2018 (5)
- June 2018 (1)
- May 2018 (1)
- April 2018 (5)
- March 2018 (3)
- February 2018 (2)
- January 2018 (2)
- December 2017 (2)
- November 2017 (3)
- October 2017 (4)
- September 2017 (5)
- August 2017 (3)
- July 2017 (3)
- June 2017 (1)
- May 2017 (1)
- March 2017 (1)
- February 2017 (3)
- January 2017 (1)
- November 2016 (1)
- October 2016 (6)
- September 2016 (1)
- August 2016 (5)
- July 2016 (3)
- June 2016 (4)
- May 2016 (7)
- April 2016 (13)
- March 2016 (8)
- February 2016 (8)
- January 2016 (7)
- December 2015 (9)
- November 2015 (12)
- October 2015 (4)
- September 2015 (2)
- August 2015 (3)
- July 2015 (8)
- June 2015 (7)
- April 2015 (2)
- March 2015 (3)
- February 2015 (2)
- December 2014 (4)
- September 2014 (2)
- July 2014 (1)
- June 2014 (2)
- May 2014 (9)
- April 2014 (1)
- March 2014 (2)
- February 2014 (2)
- December 2013 (1)
- November 2013 (2)
- October 2013 (3)
- September 2013 (2)
- August 2013 (6)
- July 2013 (2)
- June 2013 (1)
- May 2013 (4)
- April 2013 (5)
- March 2013 (2)
- February 2013 (2)
- January 2013 (2)
- December 2012 (1)
- November 2012 (1)
- October 2012 (2)
- September 2012 (3)
- August 2012 (3)
- July 2012 (3)
- June 2012 (1)
- May 2012 (1)
- April 2012 (1)
- February 2012 (1)
- December 2011 (4)
- November 2011 (2)
- October 2011 (2)
- September 2011 (4)
- August 2011 (2)
- July 2011 (3)
- June 2011 (4)
- May 2011 (2)
- April 2011 (2)
- March 2011 (3)
- February 2011 (1)
- January 2011 (4)
- December 2010 (2)
- November 2010 (3)
- October 2010 (1)
- September 2010 (1)
- May 2010 (1)
- February 2010 (1)
- July 2009 (1)
- April 2009 (1)
- October 2008 (1)