Retesting vs Regression Testing: 8 Key Differences with a Real Bug Fix Example
Retesting checks that a reported bug is really fixed. Regression testing checks that the fix, or any other change, did not break something that used to work. See both in action on one bug fix, then compare them across 8 differences you can quote in an interview.
- Retesting vs regression testing: retesting asks “is this bug fixed?”, regression testing asks “did anything else break?”.
- Retesting reruns the failed test for a known defect; regression testing reruns passing tests around the change.
- In our example, the retest passed, but the regression run caught a new bug the developer had introduced in the same commit.
- Regression suites are the best candidates for automation; retests are often manual, though automated failed tests can be rerun in seconds.
“Is retesting the same as regression testing?” is one of the most common QA interview questions, and in day-to-day work the line in retesting vs regression testing is often blurred. They answer different questions, run at different times and need different amounts of effort. To make the difference concrete, we built a small shopping cart, logged a bug, fixed it, and ran both kinds of testing with pytest 9.2.0 on Python 3.13.
Quick answer
Retesting (also called confirmation testing) means running the exact test that found a defect again, after the fix, to confirm it now passes. Regression testing means rerunning tests that already passed to make sure a change has not broken existing behaviour. You usually do retesting first and regression testing right after it.
What is retesting?
Retesting is targeted. A tester reports a bug with clear steps, the developer fixes it, and the tester repeats the same steps with the same data on the new build. If the result is correct, the bug is closed; if not, it is reopened. It follows the bug life cycle directly: “Fixed” is never “Closed” until a retest passes.
- It is planned around specific defect IDs.
- It uses the original test case and data, so a well-written bug report makes it fast.
- It cannot be skipped: a fix nobody has verified is just a guess.
What is regression testing?
Regression testing is protective. Any change, whether a bug fix, a new feature, a library upgrade or a configuration change, can have side effects. Regression tests rerun existing checks in and around the changed area to catch those side effects, which nobody reported because they did not exist yesterday.
- It is planned around risk and impact, not specific defects.
- Its scope ranges from a few related tests to the full suite.
- It runs after every meaningful change, so it benefits most from automation and CI. Our regression testing checklist covers planning it.
A real bug fix example
Our cart has two functions: total(), which applies a coupon, and shipping(), which is free above 500. Six tests cover them, including the boundary case that exactly 500 still pays shipping.
Run 1: the bug is found
FAILED test_cart.py::test_coupon_lowercase - AssertionError: assert 200 == 180
1 failed, 5 passed in 0.41s
The coupon save10 in lowercase was ignored. We logged it as BUG-101.
The fix
The developer changed the coupon check to coupon and coupon.upper() == "SAVE10". In the same commit, while “tidying up”, they also changed the shipping rule from total > 500 to total >= 500.
Run 2: retesting
$ pytest --lf
1 passed in 0.10s
pytest’s --lf (last failed) option reruns only the tests that failed last time. That is retesting in its purest form: BUG-101 is fixed.
Run 3: regression testing
$ pytest
FAILED test_cart.py::test_shipping_boundary - assert 0 == 49
1 failed, 5 passed in 0.18s
The full suite caught what the retest could not: an order of exactly 500 now shipped for free. Had the team stopped after the retest, the shipping bug would have reached production. After the developer reverted the shipping change, all 6 tests passed.
Tip: this is why “the fix is verified” and “the build is safe” are separate sign-offs. One retest proves the first; only a regression run supports the second.
8 key differences
| # | Aspect | Retesting | Regression testing |
|---|---|---|---|
| 1 | Purpose | Confirm a specific defect is fixed | Confirm changes did not break existing features |
| 2 | Trigger | A defect marked as fixed | Any code, config or environment change |
| 3 | Tests run | Previously failed test cases | Previously passed test cases |
| 4 | Scope | Narrow: the defect and its steps | Wide: affected areas up to the full suite |
| 5 | Planning basis | Defect IDs | Impact and risk analysis |
| 6 | Finds | Whether the known bug still exists | New, unexpected bugs (regressions) |
| 7 | Automation | Often manual; automated if the failing test is automated | Strong candidate for automation and CI |
| 8 | Priority and order | Done first, higher priority | Done after retesting, can run in parallel |
Which comes first?
Retesting usually comes first. If the fix does not work, the build goes back to the developer and a full regression run would be wasted effort. Once the retest passes, regression testing begins. In a CI pipeline with automated tests the distinction blurs, because every push runs the whole suite and does both at once. The concepts still matter: a pull request should state which bug it fixes (the retest) and the pipeline proves nothing else broke (the regression).
Automation: where each fits
Regression tests repeat the same checks release after release, which makes them ideal for automation. A suite that takes a manual team two days can run in minutes on every commit. Retesting is often manual, especially for UI or exploratory findings, but if the failing case is automated, rerunning it is instant, as our --lf run showed. A good habit: when a bug is found manually, add an automated test that reproduces it before the fix. The retest becomes automatic, and the test joins the regression suite forever. Our pytest tutorial shows how to write such tests.
How much regression testing is enough?
Running everything on every change is ideal but not always possible. Teams usually combine:
- Change impact: tests for code the change touches and code that depends on it.
- Risk: payments, login and data integrity always get checked.
- Smoke tests: a fast set proving the build basically works; see smoke vs sanity testing.
- Full runs nightly or before release.
Keep the suite healthy: unreliable tests that fail at random erode trust in regression results, so fix or quarantine flaky tests quickly.
Checklist: from fixed bug to safe release
- Read the fix notes. Ask the developer which files and features the change touched; that list drives your regression scope.
- Retest on the right build. Confirm the build number, then repeat the exact steps and data from the bug report.
- Try close variations. If lowercase coupons failed, also try mixed case and spaces; partial fixes are common.
- Update the bug. Close it with build and evidence, or reopen it with what still fails.
- Run targeted regression. Execute tests for the touched features and anything that depends on them.
- Run the wider suite. Smoke tests at minimum; the full automated suite where time allows.
- Add the bug’s test to the suite. Today’s retest becomes tomorrow’s regression check.
- Report clearly. State separately “BUG-101 verified fixed” and “regression: 1 new failure found”, so release decisions use both facts.
Following these steps in our example would have caught the shipping regression at step 5, before anyone signed off the release. Severity of new findings then guides what blocks the release; see our severity vs priority guide.
Interview-ready answer
“Retesting is confirming that a specific defect has been fixed by rerunning the test case that failed. Regression testing is rerunning previously passing tests to make sure the fix or any other change has not broken existing functionality. Retesting is narrow, planned from defect IDs and done first; regression testing is broader, planned from impact and risk, and is the main candidate for automation.” Add a one-line example like our coupon and shipping bug and the answer stands out.
Common mistakes
- Closing a bug after the retest alone when the fix touched shared code.
- Retesting with different data from the bug report, which can hide a partial fix.
- Calling a full rerun “retesting”; the words mean different things in test reports.
- Never updating the regression suite with tests for fixed bugs, so old bugs can quietly return.
- Bundling unrelated changes with a fix, as our developer did, which makes regressions more likely and harder to trace.
Final thoughts
Retesting vs regression testing is not either-or. Retesting tells you the bug you knew about is gone; regression testing tells you no new bug took its place. Our small example showed both sides in three runs: one failing test, one successful retest and one regression caught before release. Do both, retest first, automate the regression suite, and add every fixed bug to it.
Frequently asked questions
What is the main difference between retesting and regression testing?
Retesting confirms that a specific reported defect is fixed by rerunning its failed test. Regression testing checks that changes have not broken features that previously worked.
Is retesting the same as confirmation testing?
Yes. ISTQB calls it confirmation testing: rerunning the test cases that failed, after the defect has been fixed.
Which is done first, retesting or regression testing?
Retesting usually comes first. If the fix fails, the build returns to development; once it passes, regression testing checks for side effects.
Can retesting be automated?
Yes, when the failing test is automated, it can be rerun instantly, for example with pytest --lf. Many manual findings are retested by hand, so turn them into automated tests.
Why is regression testing usually automated?
Because the same checks are repeated after every change and release. Automation makes them fast, consistent and cheap to run on every commit in CI.
Keep learning
Need help with testing, WordPress or SEO?
We help teams ship better software and grow their sites. Tell us what you are working on and we will suggest a clear next step.