Fully Agentic Test Case Management Tool
Write, Track and Manage Every Manual or Automated Tests in One Agentic Test Management Platform with TestMu AI Test Manager.
Defect Tracking in Software Testing: Process and System Guide
Defect tracking in software testing explained: what a defect tracking system is, how to set one up, a worked defect record, key metrics, and common trackers.
Last Updated on:
Defect tracking in software testing provides a structured way to identify, record, monitor, and resolve issues throughout the development lifecycle. Without it, defects go unnoticed, leading to costly fixes later or failures in production.
Overview
Defect tracking in software testing is the process of recording every defect found, assigning an owner, and moving it through set states until a fix is verified and closed. A defect tracking system, or defect tracker, is the software that stores those records, enforces the workflow, and reports on open risk.
What Does a Defect Tracking System Hold?
- Defect record: A defect record holds the ID, title, environment, steps to reproduce, expected and actual results, severity, priority, owner, and evidence, so a developer can reproduce the defect without going back to the tester.
- Workflow states: A defect tracking system moves each defect through states such as New, Assigned, Open, Fixed, Retested, and Closed, and controls which role can make each transition.
- Severity and priority: Defect severity rates the technical impact of a defect, while defect priority sets how soon it must be fixed. A cosmetic defect on a launch page can be low severity and high priority at the same time.
- Integrations: A defect tracker connects to version control, CI pipelines, and test management, so each defect links to the commit, build, and test run behind it.
What Are the Key Defect Tracking Metrics?
- Defect density: Defect density counts defects per unit size of a work product, such as per module or per 1,000 lines of code, and shows where defects cluster.
- Defect detection percentage: Defect detection percentage is the share of known defects that a test level caught before later stages or end users found them.
- Reopen rate: Reopen rate is the share of fixed defects that fail retest and go back to the developer, a direct check on fix quality.
Is a Test Management Tool a Defect Tracker?
- TestMu AI Test Manager: TestMu AI Test Manager is a test management tool, not a bug tracker. Built-in bug tracker: No. Two-way tracker sync: Yes, with Jira and Azure DevOps. It logs a defect from a failed test to the connected tracker with steps, environment, and attachments, and syncs status changes back to the test case.
What Is Defect Tracking?
Defect tracking is the structured practice of capturing, documenting, prioritizing, and resolving each deviation from expected behavior, keeping every issue accountable from detection to closure.
The ISTQB glossary defines a defect as "an imperfection or deficiency in a work product where it does not meet its requirements or specifications or impairs its intended use" and lists bug, fault, and flaw as synonyms. Defect tracking applies to all of them, whether the deviation sits in code, a requirement, or a design.
Every step is logged with essential details and monitored through defined lifecycle stages. Following this process, teams gain accountability, improve transparency, and consistently ship higher-quality software.
Deciding which defects get fixed first is a separate step called triage. This defect triage guide covers how to run it and how to set the order of fixes.
What Is a Defect Tracking System?
A defect tracking system is software that stores each reported defect as a record and moves it through a controlled workflow, from first report to verified fix. Teams also call it a defect tracker, and it is the system of record for software defect tracking: what failed, where, how badly, who owns it, and its current state.
The Wikipedia entry on bug tracking systems treats "defect-tracking system" as another name for the same software and names a database that records facts about known bugs as a major component. Around that database, a defect tracking system usually adds:
- Record fields - the structured data on each defect, such as ID, summary, environment, steps, expected and actual results, severity, priority, reporter, assignee, and attachments.
- Workflow states and allowed transitions - a set of states and rules for which state can follow which, so a defect cannot jump from New to Closed without a fix and a retest.
- Roles and permissions - who may create, assign, resolve, verify, and close a defect. A common rule is that only a tester can close a defect a developer marked as fixed.
- Notifications - alerts to the assignee and watchers when a defect is created, reassigned, or changes state.
- Search, dashboards, and reports - saved queries such as open critical defects in the current release, and charts of defects by severity, module, and age.
- Integrations - links to version control, CI pipelines, and test management, so a defect points to the commit that fixed it and the test run that found it.
Defect tracking systems fall into a few types:
- Standalone defect trackers - built only for bugs and defects, often open source and self-hosted, with detailed defect fields and reports.
- Issue trackers inside project management suites - defects are one work item type next to stories and tasks, so they share the boards and sprint plans the team already uses.
- Trackers linked to test management - the defect lives in an issue tracker, and the test management tool links it to the test case, run, and requirement that exposed it.
Small teams often start with a spreadsheet. The table shows where a spreadsheet stops working and a defect tracking system takes over.
| Need | Spreadsheet | Defect Tracking System |
|---|---|---|
| Workflow | Any cell can change to any value | States and allowed transitions are enforced |
| Ownership | Assignee is a text column, and nobody is told | The assignee is notified on assignment and on every change |
| History | Change history is kept per file, not per defect | Every change on a defect is logged with who made it and when |
| Duplicates | Found by scrolling and filtering | Search and linking mark one defect as a duplicate of another |
| Traceability | Links to commits and test runs are pasted by hand | Links to commits, builds, and test runs come from integrations |
| Reporting | Pivot tables rebuilt for each report | Live dashboards by severity, module, and age |
Why Does Defect Tracking Matter?
Defect tracking matters because it gives teams visibility into product stability, reduces release risk, and turns scattered issues into a traceable record that improves quality and customer trust.
That traceable record only holds up when every defect follows the same states. The software bug life cycle supplies those states and the owner for each transition.
Key benefits include:
- Improved Product Quality - every defect is tracked, addressed, and resolved, which prevents leakage into production.
- Enhanced Collaboration - communication between testers, developers, and business stakeholders happens on one record, which reduces misalignment.
- Data-Driven Insights - historical defect trends reveal recurring problem areas and guide process improvement and test planning.
- Knowledge Retention - closed defects and their resolutions are a searchable record that helps prevent the same errors later.
- Compliance and Audit Readiness - formal records of defects and fixes help meet regulatory and traceability requirements in regulated industries.
Defect Tracking Lifecycle: States, Owners, and Transitions
Every defect moves through a defined set of states from the moment it is spotted until it is verified and archived. Naming an owner for each state keeps every handoff clear:
- New/Logged - a tester or user records the defect with steps, environment, and evidence. The reporter owns this stage.
- Assigned - a lead or triage owner reviews the defect and routes it to the responsible developer.
- Open/In-Investigation - the assigned developer reproduces the issue, analyzes the root cause, and confirms the fix approach.
- Fixed/Resolved - the developer implements the correction and marks the defect ready for verification.
- Retested - a tester re-runs the scenario to confirm the fix works and no regressions appear.
- Closed/Archived - once verified, the QA lead closes the defect and keeps it for trend analysis and audit history.
Most defect tracking systems also have side states. Rejected covers reports that are not defects, such as behavior that matches the specification. Duplicate links a report to an existing defect. Deferred moves the fix to a later release with a recorded reason. Reopened sends a defect back to the developer when the retest fails, and it is the state that the reopen rate metric counts.
Inside the software testing life cycle, these states are busiest during test execution. At test cycle closure, the team reviews every defect still open and fixes it, defers it with a reason, or accepts the risk before release.
Note: Run automated tests across 10,000+ desktop and mobile browsers. Start Testing Free
Defect Tracking Roles and What Each Role Owns
A defect tracking system works when each role knows which fields and transitions it owns. A typical split looks like this:
- Testers and QA engineers - find and log defects, fill in environment, steps, expected and actual results, and evidence, propose a severity, and retest fixes before moving a defect to Closed or Reopened.
- Developers - reproduce the defect, record the root cause and the fix (commit or pull request), and move the defect to Fixed. They can also mark a report as Rejected or Duplicate with a reason.
- QA lead or triage owner - runs triage, confirms severity, assigns an owner, and watches defect age and reopen rate so nothing stalls.
- Product managers and business analysts - set priority from customer and business impact, and decide which defects can be deferred to a later release.
- Project managers and engineering leads - balance defect work against feature work in each sprint and use defect trends in release decisions.
- Support and customer service teams - log defects that customers report from production, with how often they occur, which feeds the defect leakage metric.
One rule is worth writing into the workflow itself: the person who fixes a defect does not close it. A tester verifies the fix first, which keeps the Closed state meaningful.
Common Types of Software Defects Tracked
Defects show up in many forms, and categorizing them helps teams route each issue to the right owner and apply the right fix. The most common types tracked include:
- UI/UX Defects - misaligned elements, broken layouts, inconsistent styling, or confusing navigation that hurt usability without necessarily breaking core logic.
- Performance Bottlenecks - slow page loads, high memory usage, timeouts, or degraded response times under load that frustrate users and reduce scalability.
- Security Vulnerabilities - weak authentication, exposed data, injection flaws, or misconfigurations that put systems and users at risk.
- Functional Errors - features that break specification, including wrong calculations, failed workflows, or broken integrations that deviate from documented requirements.
How to Set Up a Defect Tracking System for Your QA Team
Setting up a defect tracking system is mostly a set of decisions you make once and write down. Work through them in this order:
- Choose the system type - pick a standalone tracker, an issue tracker inside your project management suite, or either one linked to test management. Developers update defects faster in the tool where their code work already happens.
- Define the defect record fields - decide which fields are required when a defect is logged and which are added later. The worked record below is a complete field set. For a reference classification of defect attributes, IEEE 1044-2009, Standard Classification for Software Anomalies, gives a uniform approach to classifying anomalies for defect causal analysis and process improvement. IEEE lists it as inactive-reserved since 2020, so treat it as a reference, not a requirement.
- Define states and allowed transitions - list the states, who can move a defect between them, and the reason codes for Rejected, Duplicate, and Deferred.
- Set severity and priority scales - write down what each level means with an example, so two testers rate the same defect the same way. Sample scales follow the worked record.
- Assign ownership and response targets - name the triage owner and set a target time to triage and to fix for each severity level, for example triage of critical defects within one business day.
- Connect integrations - link the tracker to version control, the CI pipeline, test management, and team chat, so defects carry commit, build, and test run references without copy and paste.
- Build the reports - set up dashboards for open defects by severity, defect age, and the metrics covered later in this guide, and review them at each triage meeting.
- Review the setup - after the first few sprints, check which fields go unused and which transitions cause delays, then adjust the workflow.
Worked Example: One Defect Record With Every Field
The record below is a filled-in defect for a checkout bug. Each row is a field your defect tracking system should hold, with the value a tester would enter and the reason the field exists.
| Field | Example Value | Why the Field Matters |
|---|---|---|
| Defect ID | DEF-1042, generated by the system | Gives the report one stable reference for commits, test runs, and discussion |
| Title | Checkout total ignores discount code SAVE10 when the cart has 11 or more items | A specific title lets triage spot duplicates from the list view |
| Reporter and date | QA engineer, logged during the Sprint 42 regression cycle | Shows who to ask for detail and starts the defect age clock |
| Environment | Staging build 4.18.2, Chrome on Windows 11 | Developers reproduce on the same build and platform |
| Steps to reproduce | Add 11 items to the cart, apply code SAVE10, then open the checkout page | Turns a report into something a developer can rerun |
| Expected result | Order total drops by 10 percent | States the requirement the build breaks |
| Actual result | Order total is unchanged and no error message appears | Shows the deviation that makes it a defect |
| Defect type | Functional | Routes the defect to the right team and feeds trend reports |
| Severity | 1 (High), because customers pay the wrong amount and the only workaround is to split the order | Rates technical impact on the severity scale below |
| Priority | P2 (High), fix in the current sprint | Sets fix order on the priority scale below |
| Frequency | Every time the cart has 11 or more items | Tells triage how many users can hit the defect |
| Assignee | Developer on the payments team | Gives the defect exactly one owner |
| Status history | New, Assigned, Open, Fixed in build 4.18.3, Retested, Closed | The audit trail of who moved the defect and when |
| Linked test case and run | TC-311, Apply discount to large cart, failed in the Sprint 42 regression run | Connects the defect to the test that found it and the run that verifies the fix |
| Attachments | Screenshot of the checkout page, browser console log, network capture | Evidence that removes back-and-forth between tester and developer |
| Root cause and fix | Discount loop stopped after 10 line items, fixed in the linked pull request | Feeds root cause analysis and prevention of similar defects |
Sample Severity and Priority Scales for Defect Records
Adapt the labels to your team, but keep a written description for every level. The severity scale rates impact on the system:
| Level | Description |
|---|---|
| 0 (Critical) | System blocker, no workaround, major data or function loss |
| 1 (High) | Breaks critical functions, workaround needed |
| 2 (Medium) | Affects non-critical features, workaround exists |
| 3 (Low) | Minor impact, workaround not required |
| 4 (Trivial) | Cosmetic or aesthetic defect |
The priority scale sets the order of fixes:
| Priority | Description |
|---|---|
| P1 (Urgent) | Must be fixed immediately, blocks release or core functionality for most users. |
| P2 (High) | Should be fixed in the current cycle, affects an important feature with limited workaround. |
| P3 (Medium) | Fixed once higher-priority defects are resolved, moderate impact on the user experience. |
| P4 (Low) | Fixed when time permits, minor or cosmetic issue with negligible business impact. |
Defect tracking is one part of defect management, which also covers defect prevention before testing and process improvement after the fix.
Defect Tracking Tools by System Type
The trackers below are the ones QA teams meet most often, each labelled with the system type it belongs to. For a longer side-by-side comparison, see this roundup of bug tracking tools.
- Jira - an issue tracker inside a project management suite. Bugs are one issue type alongside stories and tasks, with configurable workflows, boards, and dashboards. Jira tracks defects but not the test cases that find them, which is where Jira test management comes in.
- Azure DevOps - an issue tracker inside a development suite. Azure Boards has a Bug work item type with configurable states, queries, and dashboards, and links bugs to repositories, pipelines, and test plans, so teams can trace a reported defect to the build that resolves it.
- GitHub Issues - an issue tracker that lives next to the code. Issues sit in the same repository as the source, link to pull requests and milestones, and can close automatically when a linked pull request merges. Severity and priority usually live in labels or project fields.
- Bugzilla - a standalone, open-source defect tracker first built for the Mozilla project. Teams self-host it and get detailed defect fields, advanced search, reports and charts, and group-based access controls.
- MantisBT - a standalone, open-source, web-based bug tracker written in PHP. Teams self-host it and configure custom fields, the defect workflow, and email notifications.
- Redmine - an open-source project management web application with issue tracking, custom fields, per-tracker workflows, and links to version control repositories for traceability across projects.
How to Choose a Defect Tracking System
Choosing a defect tracking system means checking how well it fits your existing development and testing tools. A suitable tracker matches team workflows, supports integrations, and provides clear traceability across the software lifecycle.
- Integrations - compatibility with version control, CI/CD, test management, and communication platforms.
- Scalability and Workflow Flexibility - the ability to adapt states, fields, and permissions to team size, methodology, and evolving processes.
- Traceability Features - links between requirements, test cases, and defects for end-to-end visibility.
- User Experience - fast defect logging and dashboards people actually read.
- Reporting Capabilities - custom dashboards and the defect metrics your team reviews.
- Cost and Licensing - total cost of ownership, including licenses, hosting, and add-ons.
Connecting Test Runs to Your Defect Tracking System
A defect tracking system records what is broken, and a test management tool records what was tested. Connecting the two means a failed test opens a defect that already carries the test steps and environment, and a closed defect points to the run that verified the fix. Two-way tracker integration is one of the main points to compare across test management tools.
For a quick visual walkthrough of this concept, watch the video below from TestMu AI.
Subscribe to the TestMu AI YouTube channel for more tutorials on testing and automation.
TestMu AI Test Manager is not a bug tracker. It connects to the tracker you already run, with two-way integrations for Jira and Azure DevOps and 120+ integrations across the TestMu AI platform. When a test fails, Test Manager logs a defect to Jira, Azure DevOps, GitHub Issues, GitLab, or another connected tracker with the test case name, steps, expected and actual results, environment, and attachments filled in. Status changes in the tracker sync back to the linked test case, and existing tickets can be linked without creating duplicates.
Its traceability matrix connects requirements, test cases, runs, and defects in one view, and the Defects by Severity dashboard widget groups linked defects by your own Jira priority scheme. Execution data also feeds TestMu AI Test Insights for trend analysis and flaky test detection.
Common Defect Tracking Challenges and How to Avoid Them
Defect tracking keeps software quality on track, but it carries obstacles that slow teams down or create confusion. Knowing these common challenges, and how to avoid them, keeps the development process efficient.
- Incomplete or inconsistent reporting - missing steps or context hinder resolution.
- Poor triage discipline - leads to backlog mismanagement.
- Overpopulation of low-value defects - dilutes focus from critical issues.
- Tool misconfiguration - confusing workflows or inaccessible dashboards.
- Lack of integration - leads to context switching and loose traceability.
Each challenge has a matching fix:
- Enforce template standards in logging.
- Regular triage sessions with cross-functional participants.
- Archive or delete outdated defects that no longer apply.
- Set up custom workflows and simplify the UI.
- Integrate with dev and test environments to minimize friction.
Note: Catch defects earlier by running tests across real browsers and devices. Try Real Device Cloud
Best Practices for Effective Defect Tracking
Successful defect tracking goes beyond logging issues; it requires a structured approach that keeps teams aligned and focused. These practices help teams resolve defects faster and improve overall software quality.
- Use structured templates with descriptions, reproduction steps, environment, and screenshots.
- Keep a triage meeting cadence to review new defects and set priorities.
- Link defects to test cases, user stories, or requirements for traceability.
- Monitor key metrics such as defect age, mean time to resolve, and reopen rate.
- Train all team members on tool usage and definitions.
- Use automation where possible (for example, auto-create defects from failed tests).
- Run retrospectives to refine defect handling continuously.
Writing a clear and actionable bug report is essential for efficient tracking. Learn more in this guide on writing a bug report.
Defect Tracking Metrics: Density, DDP, Leakage, Reopen Rate, and Resolution Time
Defect tracking data shows where defects come from and how well the team handles them. Every metric below is calculated from fields already in your defect tracking system.
| Metric | What It Measures | How to Calculate It |
|---|---|---|
| Defect density | Defects per unit size of a work product | Defects found divided by size, for example per 1,000 lines of code or per module |
| Defect detection percentage (DDP) | How many defects a test level caught before later stages or users found them | (Defects found by the test level / (defects found by that level + defects found afterwards)) x 100 |
| Defect leakage | Defects that escaped testing and were found later, in acceptance testing or production | (Defects found after testing, in acceptance testing or production / defects found during testing) x 100 |
| Reopen rate | Fixes that failed retest or came back later | (Reopened defects / defects marked fixed) x 100 |
| Mean time to resolve | Average time from logging a defect to closing it | Total of (closed date minus created date) for closed defects, divided by the number of closed defects |
| Defect age | How long open defects have been waiting | Today minus created date, reported per severity level |
DDP measures how effective a test level is at catching defects before they reach production. The ISTQB definition of defect detection percentage is the number of defects found by a test level, divided by the number found by that test level and any other means afterwards. A high DDP means most defects are found during testing rather than by end users.
Defect leakage formulas vary. Some teams divide by total defects found instead, which makes leakage the complement of DDP. Pick one formula and keep it across releases so the trend stays comparable.
Read speed and quality metrics together. A falling mean time to resolve next to a rising reopen rate usually means fixes are being rushed through retest.
Defect vs Bug vs Issue vs Incident: Core Differences
These terms are often used interchangeably, yet each carries a distinct meaning in software development and testing. Clarifying how a defect, bug, issue, and incident differ helps teams communicate precisely and route problems correctly.
| Feature | Defect | Bug | Issue | Incident |
|---|---|---|---|---|
| Type | Deviation from expected requirements or behavior | Coding flaw that causes unintended behavior | Generic entry in tracking systems (task, request, defect, or query) | Unplanned disruption affecting performance, availability, or stability |
| Found in | Any stage such as design, development, testing, or production | Typically during development or testing | Project or issue tracking systems | Production or operational environments |
| Scope | Broader, can include design gaps, requirement mismatches, or integration | Narrow, tied specifically to code errors | Wide, covers bugs, tasks, enhancements, support requests | Critical, focused on service downtime, outages, or urgent failures |
| Severity | Can range from low to critical depending on requirement impact | Usually technical in nature, severity depends on how it breaks code | Varies, not always related to functionality (could be process or request) | High or critical, requiring immediate attention |
| Example | Feature does not meet documented business requirement | Login button does not redirect correctly | A task to update UI color scheme or investigate slow performance | Server outage preventing all users from logging in |
| Resolution | Fix requires aligning implementation with requirement | Fix requires code correction | Managed through tracking workflow such as resolve, close, or reassign | Resolved via incident management process and root cause analysis |
Understanding the nuances of bug severity and priority is crucial for efficient defect triage, as it aids in assessing the impact and urgency of issues.
Getting Started With Defect Tracking
Start by writing down your defect record fields, states, and severity scale, using the worked record above as the template, then configure them in the defect tracking system your developers already use.
To log defects from failed test runs straight into that tracker, follow the Test Manager documentation to set up the Jira or Azure DevOps integration.
Tracking tests across tools and teams? TestMu AI's Test Manager keeps test cases, runs and results in one place.
Citations
- ISTQB Glossary, defect (glossary.istqb.org), linked in the definition section above
- ISTQB Glossary, defect detection percentage (glossary.istqb.org), linked in the metrics section above
- IEEE 1044-2009, Standard Classification for Software Anomalies (standards.ieee.org), linked in the setup section above
- Wikipedia, Bug tracking system (en.wikipedia.org), linked in the defect tracking system section above
- Defect Tracking System research paper
Author
Nandini Pawar is a Tech Marketing Specialist at TestMu AI, where she creates educational content and certification programs around automation testing and AI. With certifications in Selenium, Cypress, Appium, Playwright, KaneAI, and Automation Testing, she combines technical understanding with content strategy to support the QA community. Nandini has played an active role in shaping TestMu AI’s learning ecosystem, helping thousands of testers upskill through structured, accessible resources. Her data-informed approach to content blends creativity with long-term impact, making her a valuable contributor to TestMu AI’s mission of advancing software testing education.
Reviewer
Abhishek Mishra is a Technical Product Manager at TestMu AI, where he owns Test Manager, the test management product. He has over 8 years of experience in product management and market analysis. His expertise spans across AI-native software testing, product strategy, and analytics. Previously, Abhishek served as the Product Lead at IndiaClan and co-founded Gartley618 Technologies, where he led innovative projects in quantitative trading and blockchain. He holds a B.Tech degree.
Defect Tracking FAQs
Did you find this page helpful?
More Related Learning Hubs
TestMu AI forEnterprise
Get access to solutions built on Enterprise
grade security, privacy, & compliance
- Advanced access controls
- Advanced data retention rules
- Advanced Local Testing
- Premium Support options
- Early access to beta features
- Private Slack Channel
- Unlimited Manual Accessibility DevTools Tests




















