Regression Testing: Types and When to Run It

Regression testing is the practice of re-verifying that functionality which already worked has not been broken by a change. It does not check whether a new feature is correct — that is the job of testing the feature. It answers one question: did this change break anything else? Which is why the scope of a regression run is defined by what changed, never by what exists. That definition is simple, and yet both of the common failures in regression come from getting the scope wrong. One team re-runs everything before every release, and by the third day nobody reads the results. Another tests only the code they touched, and two hours after deploy the support inbox says login is broken. The root cause is identical: nobody mapped "the change" to "the blast radius".

Four terms worth keeping apart

These four get mixed up constantly, but they test different things.
Regression Retest Smoke Confirmation
Targets Old functionality the change could have touched The specific defect just fixed Whether this build is worth testing Whether the defect is actually fixed
Input The scope of one change One bug report A new build One bug report
Who QA, often automated Reporter or QA QA or developer Reporter
Result used for Ship or do not ship Closing the defect Rejecting the build Closing the defect
Typical question "Will this change affect other modules?" "Is this actually resolved?" "Can we test this at all?" "Was it fixed the way I described?"
Two things people get wrong: retest is not regression (retest covers the one thing, regression covers the ring around it), and a green smoke run does not mean shippable (it only means the build is not broken beyond testing).

Seven types of regression

The categories matter not as vocabulary but as a decision about which to cover for a given change.
Type What it covers What triggers it
Unit regression Input and output of one function or component Logic refactors, dependency upgrades
Integration regression The contract between two modules or services API fields, error codes, authentication changes
UI regression Layout, styling, responsive breakpoints Stylesheets, component libraries, design tweaks
Regional regression Language, timezone, currency, date formats New locales, i18n copy changes
Compatibility regression Browsers, OS, resolution, devices New syntax, new CSS features, SDK upgrades
Performance regression Time to first paint, request latency, memory Bundle size, queries, caching changes
Sanity regression Whether a handful of core paths still work Any small change, as a fast self-check
For web teams the two most commonly skipped are regional and performance. Regional gets skipped because "the English site is fine". Performance gets skipped because "the feature works". Both share a trait: users notice them, and no test case has a slot for them.

When a regression run is mandatory

Not every commit needs a full pass. Five situations make skipping regression clearly more expensive than running it:
  • After a hotfix. Hotfixes are written under pressure; the change is often blunter than a normal commit and its blast radius is harder to reason about.
  • After a dependency upgrade. Framework, component library, SDK or payment gateway versions are the classic source of failures on pages nobody clicked.
  • After configuration or permission changes. Route rules, environment variables, role tables — these produce no business-logic diff, so they are the easiest to skip and the easiest to regret.
  • After changes to a shared layer. Common components, utility functions, global styles, interceptors. One edit, site-wide impact.
  • After data migration or schema changes. Table structure, field types, default values, backfills.
  • Conversely, pure copy edits, static pages and flipping a default value in a feature flag need a smoke run plus a core-path walkthrough. That is enough.

    The "what changed → what to re-run" matrix

    This table can go straight into a pull request template:
    Change type Must run Can skip
    Copy or image on a single page Smoke + that page Full regression
    Shared component or global styles UI regression (including breakpoints) + every page that uses it Performance (unless the size changed a lot)
    API field or error code Integration regression + every screen consuming it Unit regression, if already covered
    Permissions or route rules Core paths per role + behaviour without permission Performance
    Dependency or framework upgrade Compatibility + performance + full smoke —
    Schema change or data backfill Integration regression + key data screens + export UI regression, if nothing visual changed
    New locale or translations Regional regression (dates, currency, long copy wrapping, RTL if relevant) Performance
    The way to use it: classify the change first, then pick rows. Most releases need two rows, not all seven.

    Why full regression does not survive in web teams

    It is not laziness. Three structural constraints:
    • Cost grows linearly, benefit does not. Going from 50 features to 500 multiplies the run time tenfold, while the area actually touched by a given change is usually under 5%.
    • Nobody reads the output. A 300-line regression report that no one goes through becomes the phrase "we ran it".
    • The environment is unstable. Test data gets edited, third parties rate-limit, async jobs lag. Once false failures pile up, the team starts ignoring failures.
    The fix is three layers, not a longer checklist:
  • Fix a core path set (10–15 items). Login, the main flow, payment or submit, data export. Run these every time — manually is fine, automated is better.
  • Pick the blast radius from the matrix. Two or three rows, written into the pull request description.
  • Keep a list of your own minefields. Every team has them: timezones, money precision, file uploads, third-party callbacks. That list beats any generic template.
  • For what the checklist should look like, start from the website QA checklist and the web application testing checklist. Scope and cadence for the whole test effort are in the test plan template.

    How to log a regression failure (the one mistake to avoid)

    The signature failure mode of regression is "the old problem is back". What teams usually do is file a brand new defect, and then:
    • the same problem appears twice in the system, so every count is wrong;
    • the root cause analysis that took three days last time has to be redone;
    • whoever fixes it does not know it is the second occurrence, so they apply the same fix that failed before.
    The correct move is to link back to the original report; do not create a new one. Three steps:
  • Comment on the original defect: what change triggered the reappearance, in what environment, at which version.
  • Change the status from Closed back to Reopened, and mark it reopened in the title or labels.
  • Attach this round's evidence (screenshot, recording, console errors, failed request) under the original report rather than in a new one.
  • All of that depends on one thing: the evidence in the original report still exists and still opens. This is exactly where most teams stall at regression time — the screenshot from three months ago either points at an expired link or requires the original reporter to log in. So the practical advice is to make report evidence durable per record instead of per chat thread. BugCapturer's share links support an expiry date and password protection, and reports are retained long-term on the team plan — for the same reason: when the bug comes back, the original screenshot and the original request are still there. See also sharing bug reports with clients.

    A regression failure template

    A usable regression record has six fields. Miss one and you buy another round trip.
    text
    Regression scope: site-wide styling after the shared Button component upgrade
    Build: v1.6.6 (2026-11-16 build)
    Environment: Chrome 141 / macOS 14 / 1440x900
    Symptom: on checkout, "Place order" does nothing; every other page is fine
    Evidence: console TypeError: Cannot read property 'onClick' of undefined
              Network: POST /api/orders was never sent
    Related: original defect #482 (2026-08-12, same cause: Button props not forwarded)
    
    That last line is the point. It connects "now" to "last time", and the developer knows not to start from zero.

    Six rules for regression discipline

  • Write the scope before you start. A regression run without a written "this time we only cover X" becomes "click everything".
  • The change description names the blast radius. That is the author's job, not QA's guess.
  • Handle false failures the same day. A failure once labelled "environment issue" will not be taken seriously the second time.
  • Never skip the core paths. Even for a one-word change.
  • Do not file a new defect for a regression failure. Link the original and add evidence.
  • Backfill the matrix after every incident. The row you missed is the row to change.
  • For what happens after you find a problem, see bug triage: what to fix first and the full loop of fixing a bug. If you are still deciding how deep to test, black box vs grey box vs white box has the comparison. Where acceptance ends and regression begins is covered in the UAT guide and SIT vs UAT.

    Frequently asked questions

    What is the difference between regression testing and retesting? Retest verifies "the one defect that was just fixed". Regression verifies "the old functionality the change could have touched". After a fix, retest to confirm it is gone, then regress to confirm nothing around it broke. The order matters. Should every release get a full regression pass? No, and it is not practical. Use the change-to-blast-radius matrix to narrow to two or three rows, plus 10–15 core paths every time. Full passes belong to dependency upgrades and data migrations. Can regression testing be fully automated? The core paths can and should be. But automation is good at "walk this path again" and bad at "is this result reasonable". Misaligned layouts, wrong copy and degraded feel still need a human glance. In practice: automation runs the regression, people look at the exceptions. How often should it run? Follow the release cadence, not the calendar. Ship three times a day and regression belongs in CI. Ship weekly and one manual pass before each release is enough. What matters is that scope follows the change. When a regression fails, should I file a new defect or reopen the old one? Reopen the old one and attach this round's evidence under it. Filing a new one breaks the information "this has happened before" and restarts the root cause analysis from zero.