Bug Life Cycle in Software Testing: 9 Stages Explained With Examples
Follow one bug from New to Closed, see who owns each stage, and map every status to Jira and GitHub.
Every bug has a story, and the bug life cycle is that story told in order, from "someone spotted it" to "someone proved it is gone." Now 84% of developers use or plan to use AI coding tools, per Stack Overflow's 2025 Developer Survey.
The same survey found 66% of developers call AI-written code "almost right, but not quite." More bugs are coming, yet most teams cannot agree on what "fixed" means, so duplicates sit open and nobody knows how long a bug takes to close.
This guide follows a bug through all 9 stages, shows who owns each one, and maps the same states onto Jira, Bugzilla, Azure Boards and GitHub. By the end, every failing test in your test failure analysis will have an obvious next step.
What is the bug life cycle in software testing?
The bug life cycle, also called the defect life cycle, is the sequence of statuses a reported bug passes through from the moment it is logged until it is verified and closed. Each status has one owner and one exit condition, so everyone knows what happens next.
The ISTQB Foundation syllabus describes the same idea without naming it. It says a defect management process needs, at minimum, "a workflow for handling individual anomalies from their discovery to their closure and rules for their classification", per the ISTQB CTFL v4.0 syllabus.
The word "anomaly" is doing careful work there. A new report might turn out to be a real defect, a false alarm, or a request for a change. Deciding which one it is happens inside the cycle, not before it starts.
Bug, defect and failure are 3 different things
The syllabus separates three terms that everyday speech blurs together. A person makes an error, the error leaves a defect in code or documentation, and running that defect can produce a failure that a user or a test observes.
The split matters because a test only ever sees the failure. The report describes the failure, the developer hunts for the defect, and a good retrospective looks for the error behind it. That last step is what root cause analysis means in practice, and it is how teams stop the same class of bug from coming back.
Defect life cycle vs software testing life cycle
The defect life cycle in software testing is not the same thing as the software testing life cycle. The testing life cycle covers planning, design, environment setup, execution and closure for a whole test effort.
The bug life cycle starts inside the execution phase, every time a test or a person finds a failure, and it runs in parallel for every open defect.
Because it lives inside execution, it looks slightly different across the types of software testing a team runs. An exploratory session produces bugs by hand, one at a time. An automated regression suite produces them at scale, which is exactly why each status needs to be crisp before the volume arrives.
Knowing what the cycle is only pays off once you know what it costs to skip it.
Why a clear defect life cycle matters more than your tracker
A tracker gives you fields. The bug life cycle gives you agreement on what those fields mean. Without that agreement, three things go wrong in almost every team:
-
A status with no owner becomes a waiting room, and bugs sit there for weeks.
-
"Fixed" means "I pushed a commit" to one person and "a tester confirmed it" to another.
-
Nobody can measure the cycle, so nobody can shorten it.
The cost of that drift has been measured. In 2002, the National Institute of Standards and Technology surveyed developers about how many hours it took to investigate and fix a bug depending on where in the process it was found.

A bug caught during coding or unit testing took 2.4 hours on average. The same kind of bug found after release took 13.1 hours, more than 5 times longer, according to NIST Planning Report 02-3. The report also put the national cost of inadequate testing infrastructure at $22.2 billion to $59.5 billion a year.
Newer data points the same way. The Consortium for Information and Software Quality estimated the cost of poor software quality in the United States at $2.41 trillion for 2022 in its Cost of Poor Software Quality in the US report.
The same report states that "the cost of finding and fixing deficiencies is the largest single expense element in the software development lifecycle". Finding and fixing is exactly what the bug life cycle organises.
Note: The bug life cycle only covers what happens after a bug is found. The cheapest stage is the one a bug never reaches, which is why shift-left testing and a clean defect workflow belong in the same conversation.
Once a bug does enter the tracker, the only questions that matter are where it is and who moves it next.
The 9 stages of the bug life cycle explained
Ask ten teams to list the stages of the bug life cycle and you will get ten slightly different lists. The sequence below matches the default workflows of the trackers covered later in this guide, with some of them merging two steps into one.
- New: the bug is logged with steps, expected and actual results, environment and evidence.
- Assigned: triage confirms it is real and not a duplicate, then hands it to a developer.
- Open: the developer reproduces the failure and works on a fix. Jira calls this In Progress and Azure Boards calls it Active.
- Fixed: the code change is merged and tagged with the build that carries it.
- Pending retest: the fix waits for a tester to pick it up on that build.
- Retest: the tester reruns the original steps and checks nearby behaviour for regressions.
- Reopened: the retest failed, or the bug came back, so it returns to the developer with new evidence.
- Verified: the retest passed and someone other than the fix's author has confirmed it.
- Closed: the resolution is recorded and the bug drops out of the active list.

Stages 1 to 3: detection and triage
A bug in New is a claim, not a fact. Triage turns it into a fact by reproducing it once, checking for duplicates, and setting severity and priority before anyone writes code. Skipping this step is how a cosmetic typo and a checkout crash end up in the same queue.
Automation changes the shape of this phase. When hundreds of end-to-end tests run on every pull request, many new bugs arrive as failed test results rather than hand-written reports. Attaching the Playwright trace viewer recording to the report replaces a paragraph of prose with something the developer can scrub through.
Stages 4 to 6: fix, hand off and retest
Fixed is the most misread status in the cycle. It means the developer believes the change works, and nothing more. The build number is the real handoff: without it the tester cannot know which build to retest, and Pending Retest can quietly become the stage where bugs wait longest.
For automated suites, retest can be nearly free. The failing test that opened the bug is rerun against the fix, and teams that rerun only failed tests get that answer in minutes instead of waiting for a full pipeline.
Stages 7 to 9: reopen, verify or close
Verified and Closed are separate for a reason. Verified says the fix held on the named build. Closed says the paperwork is done: resolution recorded, test linked, follow-ups filed.
Microsoft keeps the roles apart in the same way. In Azure Boards, the developer resolves the bug, and then "the person who created it verifies the fix and closes it", per Manage bugs in Azure Boards.
Reopened is the loop that keeps everyone honest. Every reopen means the verification half of the cycle ran twice, and it usually means the first fix treated a symptom. Checking the test's test history across several runs before closing separates a real fix from a lucky pass.
Note: Status names are not standardised. Bugzilla ships UNCONFIRMED, CONFIRMED, IN_PROGRESS, RESOLVED and VERIFIED. Azure Boards uses New, Active, Resolved and Closed in its Agile process. Map your team's labels onto the 9 roles above instead of arguing about the words.
A list of stages stays abstract until you watch one bug walk through it.
Bug life cycle example: 1 checkout bug from New to Closed
Here is the same cycle with a concrete bug: a coupon code that should take 10% off a cart but does not. The example uses an online store, but the handoffs are the same for any product.
| Stage | Owner | What happens in the example |
|---|---|---|
| New | Tester | Logs BUG-4821: "Apply code SAVE10 to a cart of 2 items totalling 100.00; expected 90.00, actual 100.00", with a trace attached |
| Assigned | Triage lead | Reproduces it on staging, finds no duplicate, sets severity High and priority P2, assigns the checkout team |
| Open | Developer | Finds the discount is applied before the tax step recalculates the total, so the total is overwritten |
| Fixed | Developer | Merges the fix and records build 2.14.0-rc4 on the ticket |
| Pending retest | Developer | Ticket waits until rc4 is deployed to staging |
| Retest | Tester | Reruns the original steps on rc4, then checks percentage and fixed-amount coupons too |
| Verified | Tester | Total shows 90.00, and the linked test passes on 10 consecutive runs |
| Closed | Tester | Resolution Fixed, test ID linked, root cause noted in the final comment |
Notice what never happened. Nobody asked "which build has the fix?" because the developer wrote it on the ticket. Nobody argued about whether the bug was real, because triage reproduced it once before assigning it. And the bug never hit Reopened, because the retest covered the neighbouring coupon types, not only the exact steps.
Why this example closed without a reopen
Three habits did the work. The report used concrete data instead of "apply a coupon". The fix carried a build number. And the tester checked the test's run history before closing instead of trusting a single green run.
Those habits are cheap, and they are the difference between a bug life cycle that takes a day and one that takes a sprint. Teams that trace each Playwright test failure back to its ticket get the same effect without the manual bookkeeping.
Alternate bug statuses: rejected, duplicate, deferred and cannot reproduce
Every tracker has side exits from the main path, and they are not failures of the process. A report that is not a bug should leave the queue quickly, with a written reason, so the people fixing real defects are not scrolling past it.
The trackers ship with these exits built in. Bugzilla's default resolutions include FIXED, INVALID, WONTFIX, DUPLICATE and WORKSFORME, where WORKSFORME means "all attempts at reproducing this bug were futile", per the Bugzilla documentation.
Jira's defaults carry the same meanings under friendlier names. Its resolutions include Done, Won't Do, Duplicate and Cannot Reproduce, where Cannot Reproduce means "all attempts at reproducing this work item failed, or not enough information was available", according to Atlassian's statuses, priorities and resolutions page.

The table below covers the exits most teams need, who usually sets them, and what should happen next.
| Status | What it means | Who usually sets it | Typical next step |
|---|---|---|---|
| Rejected / Not a bug | The behaviour is correct or the report is invalid | Developer or triage lead | Close with a reason; the reporter may reopen with new evidence |
| Duplicate | The same defect already has a report | Triage lead | Link to the original and close |
| Deferred | Valid bug, but not for this release | Product owner | Tag with a target release and revisit at planning |
| Cannot reproduce | Nobody can trigger the failure with the given steps | Developer | Request more information, then close if nothing arrives |
| Need more information | The report lacks steps, environment or evidence | Developer | Return to the reporter; auto-close after a set period |
| Won't fix | Real, but the cost or risk of fixing outweighs the benefit | Product owner | Document the decision and the workaround |
Deferred vs rejected: the difference that hides bugs
Rejected says the software is behaving correctly. Deferred says the software is wrong, but fixing it now is not worth the schedule hit or the risk. Marking a real defect as Rejected hides it forever. Marking it Deferred keeps it visible for the next planning session.
A simple rule keeps the two apart: only a product owner can defer, while a developer can reject. Release trade-offs stay with the person accountable for the release, and technical judgment stays with the person who read the code.
Cannot reproduce is often a flaky test in disguise
In automated suites, Cannot Reproduce is the most abused exit. A test fails once on CI, passes locally, and the report is closed. Two weeks later it fails again. Those are not two bugs. That is one intermittent defect, and it belongs with flaky tests, not in the closed pile.
The fix is procedural. Before closing anything as Cannot Reproduce, check that test's failure rate across recent runs. Dedicated flaky test detection tools surface a test that fails 1 run in 8 as a pattern instead of 8 unrelated reports.
From there, a structured flaky test analysis tells a genuine race condition apart from a one-off environment blip, and only the first of those deserves a ticket.
With the statuses settled, the next question is who is allowed to move a bug between them, and that is about people, not tools.
Who owns each stage: roles, severity and priority
A status without an owner is a status where bugs go to wait. The clearest workflows assign exactly one role to each transition, so "who moves this next" never needs a meeting.
| Transition | Owner | What they must provide |
|---|---|---|
| Log as New | Tester, developer or user | Steps, expected vs actual, environment, evidence |
| New to Assigned | Triage lead or product owner | One reproduction, severity, priority, assignee |
| Assigned to Open | Developer | Acknowledgement and a confirmed root cause |
| Open to Fixed | Developer | Merged change and the build number that carries it |
| Fixed to Verified | Tester (not the fix author) | Retest result on the named build |
| Verified to Closed | Tester or triage lead | Resolution and any follow-up links |
| Any state to Reopened | Tester | New evidence and the build where it returned |
Testers own both ends of the cycle. They write the report that starts it and run the retest that ends it. Good test reporting makes both ends cheaper, because the same artefacts that describe the bug also prove the fix.
Developers own reproduction, root cause and the fix, plus one piece of paperwork that teams skip constantly: the build number. Azure Boards gives it a dedicated field, Integrated in Build, for exactly that reason. Tagging the guarding test with its bug ID through Playwright annotations closes the loop from the other side.
Severity vs priority in the bug life cycle
Severity measures damage. Priority measures urgency. Different people set them for different reasons, and a bug can score high on one and low on the other without any contradiction.
Azure Boards spells the scales out in its bug template. Severity 1, Critical, is a defect that causes "termination of one or more system components or the complete system, or causes extensive data corruption" with no acceptable workaround. Severity 4, Low, is "a minor or cosmetic defect that has acceptable workarounds".
Jira's priority names carry the urgency side. Highest is a problem that "will block progress", while Lowest is a "trivial problem with little or no impact on progress", per Atlassian's documentation linked above.
| Combination | Example | Handling |
|---|---|---|
| High severity, high priority | Checkout charges the wrong total | Fix now, block the release |
| High severity, low priority | Crash in a legacy export used twice a year | Schedule for a later sprint, document the workaround |
| Low severity, high priority | Company name misspelled on the login page before a launch | Fix before launch, trivial effort |
| Low severity, low priority | Tooltip off by 2 px in one browser | Backlog, defer if needed |
Tip: Let the tester set severity at report time and let the product owner set priority at triage. When one person sets both, the two fields collapse into a single "how much I care" score and lose their value.
Metrics that expose a slow bug life cycle
Three timings tell you where a cycle is stuck. Time from New to Assigned shows whether triage keeps up. Time from Fixed to Verified shows whether testers have the builds they need. Reopen rate shows whether fixes are real. They sit alongside broader test quality metrics such as escaped defects per release.
Pair those timings with money and the priorities get easier to argue. The cost of bugs in each area of the product shows where root-cause work pays back fastest.
For a production bug, TestDino's free Bug Cost Calculator turns its severity, industry and user base into a dollar estimate you can put in front of a product owner, which is a much shorter conversation than "trust me, it matters".
Every one of those fields lives in a tracker, and each tracker implements the cycle in its own vocabulary.
Bug life cycle in Jira, Bugzilla, Azure Boards and GitHub
Jira, Bugzilla, Azure Boards and GitHub Issues name the same states differently, but they agree on the shape of the cycle far more than their labels suggest. The infographic below lines up their default names for the same 8 situations.
![]()
Bug life cycle in Jira
Jira separates status from resolution, and that split is the whole point. A status "indicates its current place in the space's workflow", in Atlassian's words, while a resolution records how the work ended. A bug can sit in Done with a resolution of Done, Won't Do, Duplicate or Cannot Reproduce, and reports can filter on either field.
A new Jira software project starts with To Do, In Progress and Done, and teams add In Review, Ready for QA or Reopened as they need them. Because Jira lets any status be renamed, the shared vocabulary matters more than the tool.
Teams that manage test cases in Jira usually link each bug to the test that found it, which turns the retest step into a one-click jump.
Bugzilla, Azure Boards and GitHub Issues in brief
Bugzilla's default workflow reads like the classic textbook diagram. It runs UNCONFIRMED, CONFIRMED, IN_PROGRESS, RESOLVED and VERIFIED, and its docs describe VERIFIED as the point where "QA has looked at the bug and the resolution and agrees that the appropriate resolution has been taken".
Azure Boards attaches a Reason to every state change. Closing a bug in the Agile process offers Fixed, Deferred, Duplicate, As Designed, Cannot Reproduce, Obsolete and Copied to Backlog. Microsoft also recommends not reopening closed bugs for regressions: open a new bug and link it to the original, so the history of each fix stays intact.
GitHub Issues keeps the model minimal. An issue is Open or Closed, and a closed issue carries a reason of completed, not planned or, since GitHub's December 2024 Issues changelog, duplicate. Severity and priority are labels.
GitHub does automate the Fixed transition, though. A closing keyword in a pull request description closes the linked issue when the PR merges into the default branch, per GitHub's linking a pull request to an issue docs.
Fixes #4821
Coupon SAVE10 is now applied to the subtotal before tax.
The supported keywords are close, closes, closed, fix, fixes, fixed, resolve, resolves and resolved. Teams running Playwright in GitHub Actions often pair this with a required check, so the merge that closes the bug is the same merge that proves the regression test passes.
Whichever tool you use, the cycle is only as fast as its slowest handoff, and most handoffs can be made faster without cutting a single stage.
How to shorten the bug life cycle without skipping stages
There are only two levers. Fewer bugs can enter the cycle, which means catching them before they reach a tracker. And the bugs that do enter can move faster, which comes down to the quality of the report and how much of each handoff is automated.
The first lever is the NIST data from earlier. A defect caught by a unit test on a developer's laptop never enters the tracker at all, which is the case for running end-to-end suites on every pull request rather than nightly.
Per-PR runs cost CI minutes, and the point of Playwright CI cost optimization is to keep that loop affordable, not to run fewer tests.
Write a bug report a developer can act on first time
A bug report is a handoff document. Its only job is to let a developer who has never seen the failure reproduce it on the first attempt. The ISTQB syllabus lists what a defect report typically contains, and the infographic below shows those fields the way a developer wants to read them.

The syllabus items are an identifier, a title and short summary, the date, organisation and author, the test object and environment, the test context, a description of the failure with steps and logs, expected and actual results, severity, priority, status and references.
Trackers fill in several of these automatically, which leaves the reporter responsible for the three that matter most: steps, results and evidence.
Steps should be numbered, start from a known state and use concrete data. "Apply a coupon" is a guess. "Apply code SAVE10 to a cart containing 2 items totalling 100.00" is a test. Expected and actual results belong on two separate lines so the gap is visible at a glance.
Evidence is where automation earns its place. A Playwright trace captures every action, network call, console message and DOM snapshot leading up to a failure, and it attaches to a ticket as a single file.
export default defineConfig({
use: { trace: 'retain-on-failure', screenshot: 'only-on-failure', video: 'retain-on-failure' },
});
With that configuration, every failed test already produces the evidence section of its own bug report. The Playwright debugging guide covers how to read those traces and move a bug from New to a confirmed root cause quickly.
Tip: When a bug is deferred, mark the test that exposes it as an expected failure and reference the bug ID. The suite stays green, the bug stays visible, and the day the fix lands the test flips to "unexpectedly passed" and tells you to retest.
test('coupon reduces cart total', async ({ page }) => {
test.fail(true, 'BUG-4821: SAVE10 not applied before tax, deferred to 2.15');
// steps that currently fail
});
Let CI results and the tracker talk to each other
The slowest part of many bug life cycles is not the fixing. It is the manual copying between a failed CI run and a tracker ticket, then back again at retest.
Modern AI test management tools close that gap by grouping failures by root cause, attaching artefacts automatically and keeping the link between a test and its bug alive across runs.
TestDino approaches this as a test intelligence platform for Playwright teams. Failures from CI arrive already sorted into product bugs, test bugs and flaky runs, with traces attached, so the New and Assigned stages are largely automated.
For teams that write and repair tests with AI coding agents, the open-source playwright-skill gives those agents the conventions to produce traces and annotations that fit this flow.
That matters when an agent is pointed at fixing Playwright tests with AI. The call on whether a failure is a product bug or a test bug has to be made before the agent touches anything, and a clean bug life cycle is what makes that call visible.
Conclusion
The bug life cycle is a simple idea with a lot of surface area. A bug is reported, confirmed, assigned, fixed, retested and closed, with side exits for reports that are duplicates, invalid, deferred or impossible to reproduce. Every move needs one owner and one written reason.
The tools differ in vocabulary, not in shape. Jira splits status from resolution, Bugzilla runs UNCONFIRMED through VERIFIED, Azure Boards attaches a reason to every change, and GitHub keeps Open and Closed with three close reasons. Mapping your team's labels onto the same 9 stages removes most of the arguments.
The cost evidence points one way. NIST found post-release bugs took more than 5 times the hours of bugs caught during coding, and CISQ still names finding and fixing defects as the largest single expense in the development lifecycle.
The cheapest stage of the bug life cycle is the one a bug never reaches. Fast test runs and a clear software testing report are part of defect management, not a separate activity.
If you change only two things after reading this, make them the cheap ones: put a build number on every Fixed ticket, and check a test's run history before you close its bug.
FAQs

Pratik Patel
Co-founder
