Software Testing

Beginner path · lesson 23 of 35

BeginnerFundamentals5 min readPublished November 12, 2026

The bug life cycle: from New to Closed

Every bug moves through a series of statuses: New, Assigned, Fixed, Retest, Closed, and sometimes Reopened, Rejected, Duplicate or Deferred. Here's what each status means, who moves the bug, and what the tester does at each step.

On this page

Key takeaways

  • The bug life cycle (or defect life cycle) is the path a bug takes from being reported to being closed. Each stop is a status in the bug tracker.
  • The main path is New → Assigned → In progress → Fixed → Ready for retest → Closed. Side exits include Rejected, Duplicate, Deferred and Cannot reproduce, and a failed retest sends the bug back as Reopened.
  • The tester opens the bug and, usually, is the one who closes it, after confirming the fix works.

Why bugs need a life cycle

A team might have hundreds of open bugs at once. Without clear statuses, nobody knows which ones are being fixed, which are waiting for a decision, and which are ready to check.

The life cycle answers one question for every bug: whose move is it now?

The main path

  1. New. You've found a problem and logged it with a clear bug report.
  2. Assigned (or Open). During triage, someone (a lead or product owner) accepts it as a real bug, sets its priority and assigns it to a developer.
  3. In progress. The developer is working on the fix.
  4. Fixed (or Resolved). The developer has changed the code and believes the problem is solved.
  5. Ready for retest (or In QA). The fix has been deployed to a test environment. Now it's the tester's move.
  6. Closed (or Verified). The tester retested it using the original steps, the bug is gone, and nothing nearby broke.

When things don't go to plan

StatusMeaningWhat the tester does
ReopenedThe retest failed: the bug is still there, or only partly fixed.Add what you saw this time (build, steps, evidence) and send it back.
Rejected (Not a bug)The team decides the behaviour is correct or intended.Check the requirement. If you still disagree, discuss it with facts, not just in comments.
DuplicateThe same problem is already reported.Link the two. Add any new details to the original.
Deferred (Postponed)It's a real bug, but it won't be fixed in this release.Make sure the risk is understood and the bug isn't forgotten.
Cannot reproduceThe developer couldn't make it happen.Add more detail: environment, data, account, video, logs. Try to reproduce it together.

The flow as a picture

New ──► Assigned ──► In progress ──► Fixed ──► Ready for retest ──► Closed
 │          │                                        │
 │          ├──► Deferred                            └──► Reopened ──► Assigned
 │          └──► Rejected / Duplicate / Cannot reproduce
 └──► (triage)

Retesting: closing a bug properly

Closing a bug is a promise that it's fixed. Before you close it:

  • Retest with the original steps and data, on the build that contains the fix. Check the build number.
  • Test around the fix. If the bug was "discount wrong for 2 items", also try 1, 3 and 10 items, and other discount types.
  • Check related areas for side effects. That's regression testing.
  • Add a short comment: "Verified on build 4.2.1 (staging), Chrome and Safari. Also checked 1, 3 and 10 items."
Real-world exampleClosed, reopened, closed, reopened

A tester reported that the "Forgot password" email never arrived. The developer found a typo in the email template name, fixed it and marked the bug Fixed. The tester retested with their own account, received the email and closed the bug.

Two days later, support received complaints: users with a + in their email address, like ana+shop@example.com, still got nothing. The bug was reopened. The real cause was a second problem: the address wasn't encoded correctly before sending.

After the second fix, the tester retested with a plain address, an address with +, one with a dot, and one with uppercase letters. Only then did they close it, listing all four in the comment.

Lesson: "it works for me" isn't verification. Retest with the original data, then test the variations around the fix.

Tips for working with the life cycle

  • Don't close bugs you haven't retested. Even if the developer is sure.
  • Don't reopen for a different problem. If the original bug is fixed but you found a new one, log a new bug and link them.
  • Keep comments factual. The bug's history is read later by people who weren't there.
  • Watch the Deferred pile. Deferred bugs pile up silently. Ask for them to be reviewed regularly.

Do

"Reopened. Still reproducible on build 4.2.1 (staging) with an address containing '+'. Plain addresses now work. Video attached."

Don't

"Still broken." No build, no data, no evidence, so the developer has to start the investigation from scratch.

Check yourself

A developer marks your bug as 'Rejected – works as designed'. You think users will find the behaviour confusing. What do you do?

Show answer

First, check the requirement or design. If the behaviour matches it, the bug may be correctly rejected as a defect, but your concern is still valid. Raise it as a usability issue or improvement with the product owner, explaining the user impact. They decide whether to change the design. Don't just reopen the same bug.