Test automation

What Is Regression Testing? Types, Examples and When to Automate It (2026)

Aslam KhanAslam Khan 10 min read
Stack rock on seashore — Regression Testing in Software Testing

The fix was one line: a rounding change in the tax calculation. It shipped on Tuesday. On Thursday, finance noticed that every refund since Tuesday had been a cent short, because the refund screen used the same function.

Nobody broke refunds on purpose. Nobody re-checked them either. That gap is what regression testing closes.

Regression testing is re-running tests on existing features after a code change to confirm that nothing that used to work has broken. It covers bug fixes, new features, refactors, dependency upgrades and configuration changes, and is usually automated so it can run on every merge and before every release.

Key takeaways

  • A regression is a defect in behaviour that used to work. Regression testing exists to catch it before users do.
  • You rarely need to run everything. Choose tests by risk: what changed, what it touches and what costs most when it breaks.
  • Automate the stable, repeatable core and keep exploratory and judgement-based checks manual.
  • Regression testing pays off when it runs in CI/CD and its failures block a merge or release.

What is regression testing?

Regression testing verifies that recent changes haven't introduced unintended side effects in functionality that was already tested and working. The word "regression" means going backwards: the software was correct, and now it isn't.

Any change can cause one. A bug fix can break a neighbouring feature, a library upgrade can change a default, and a new field can shift a layout. Regression tests re-check the existing behaviour around a change, not just the change itself.

This page is the overview. For depth, read our guides to automated regression testing (building a suite that runs in CI and stays reliable) and manual regression testing (templates, prioritisation and running a manual pass well).

Why does regression testing matter?

Software is connected. Functions are reused, components share state and services call each other, so a change in one place can fail somewhere nobody looked.

  • It catches regressions early, when the cause is one recent change and the fix is cheap.
  • It lets teams change code with confidence, which is what frequent, agile releases depend on.
  • It exposes integration conflicts when separately correct changes interact badly.
  • It protects users' trust. A broken feature that used to work feels worse than a missing one.

Without it, every release is a bet that nothing nearby moved.

What are the types of regression testing?

Types describe how much you re-run and why. Most teams use several, depending on the change.

TypeWhat it meansTypical use
Unit regressionRe-running the unit tests for the changed code in isolationEvery commit
Partial regressionTesting the change plus the existing areas it directly interacts withSmall, contained changes
Selective regressionRunning a chosen subset of the suite, based on what the change could affectMost day-to-day merges
Complete (retest-all) regressionRunning the entire regression suiteMajor releases, framework or platform upgrades
Corrective regressionRe-running existing tests unchanged, because requirements haven't changedRefactoring, performance tuning
Progressive regressionUpdating or adding tests because requirements changed, then running them with the existing suiteNew or changed features
Visual regressionComparing screenshots against approved baselines to spot unintended visual changeCSS, design-system and layout changes
Performance regressionChecking response times or throughput against a baseline or thresholdQuery, caching or infrastructure changes

Visual regression is built into some frameworks. Playwright's toHaveScreenshot() generates reference screenshots on the first run, compares later runs against them, and stores baselines per browser and platform because rendering differs between them.

Performance regression needs a pass/fail rule. In k6, a threshold such as p(95)<200 on request duration fails the test and returns a non-zero exit code when it's breached.

What does regression testing look like in practice?

Four short examples show how the type follows from the change.

A bug fix (selective). A developer fixes the discount code field so it accepts lowercase codes. The regression run covers checkout with and without codes, expired codes, order totals, the order confirmation email and the refund flow, because all of them read the discounted price.

A dependency upgrade (complete). The team upgrades its payment SDK by a major version. Payments touch checkout, subscriptions, invoices and refunds, so the full regression suite runs, plus the nightly long-journey tests.

A stylesheet refactor (visual). Buttons move to new design tokens. Functional tests still pass, but visual regression shows the "Delete account" button now has the same colour as "Save". That's a regression a functional check would miss.

A database index change (performance). A migration changes an index on the orders table. Functional tests pass; the performance threshold on the order search endpoint fails, so the change goes back before release.

How is regression testing different from retesting, smoke and sanity testing?

These terms get mixed up. The difference is what each one is trying to prove.

Regression testingRetestingSmoke testingSanity testing
QuestionDid this change break anything that worked?Is this specific bug fixed?Is the build stable enough to test at all?Does this specific change basically work?
ScopeExisting features around the change, up to the whole suiteThe failed test case(s) onlyA small set of critical pathsA narrow area tied to the change
WhenAfter any change, every merge or releaseAfter a fix is deliveredOn every new build or deploymentAfter a minor fix or change, before deeper testing
Automated?Usually, for the stable coreOften manualAlmost alwaysOften manual

Retesting and regression testing usually happen together: retest the fixed bug, then regression-test around it. Our guide to smoke testing covers the fastest layer in more detail.

How do you choose which regression tests to run?

Running every test after every change is rarely practical, so most teams use risk-based selection. Score the candidate tests on four questions:

  1. Change impact. Does the test touch code, data or configuration that changed, or something that calls it?
  2. Business criticality. What does it cost if this journey breaks: revenue, compliance, data, reputation?
  3. Defect history. Has this area regressed before? Past bugs predict future ones.
  4. Integrations. Does it cross a boundary such as payments, identity or a third-party API?

High on any two usually means it runs. Your top-risk journeys form a smoke set that runs on every change regardless.

Tooling can help with the first question. Jest's --onlyChanged and --changedSince options pick tests related to files changed in the repository or since a given branch or commit. Change-based selection works best at unit level; for end-to-end journeys, a maintained mapping from features to tests is more reliable.

Test selection is one of three classic regression challenges. The other two are environments that don't match production and test data that drifts between runs. Plan for all three from the start.

When should you automate regression testing?

Automate a regression test when it runs often, its expected result is clear and stable, and the journey matters. That describes most of a regression suite, which is why regression is usually the first testing that teams automate.

Good candidates:

  • Core journeys: sign-up, login, checkout, the main transaction
  • Data-driven variations of the same flow (currencies, roles, plans)
  • API and permission checks
  • The same flows across browsers and screen sizes
  • Anything run in every release that hasn't changed for several releases

The step-by-step build, from layering the suite to running it in parallel and controlling test data, is in our guide to automated regression testing.

What should you NOT automate?

Automation has costs: building, running and maintaining every test. Some regression checks don't repay them.

  • Features still changing every sprint. Wait until the design settles, or you'll rewrite the test weekly.
  • Judgement calls. Whether a layout "feels right" or copy reads well needs a person. Visual baselines catch change, not quality.
  • One-off checks. A migration you'll run once is better verified by hand.
  • Exploratory regression. Unscripted sessions around a risky change find problems scripted tests can't anticipate.
  • Tests with no stable oracle. If nobody can say what the correct result is, automating it only automates confusion.
  • Low-value, low-risk screens where a failure costs less than maintaining the test.

Our manual regression testing guide covers how to run these checks well, including session charters for exploratory regression.

What are automated regression testing best practices?

  • Document each test's purpose, expected result and dependencies, so failures are easy to read.
  • Keep tests in version control alongside the code they check.
  • Select by risk, and review the suite regularly to remove duplicates and dead tests.
  • Give each test its own data, or reset a known dataset before each run.
  • Run in parallel so suite time depends on the slowest test, not the total.
  • Treat flaky tests as defects: quarantine, fix, then restore.

How does regression testing fit into CI/CD?

Regression testing only protects you if it runs without anyone remembering to start it. Most teams split it into layers.

Pipeline stageRegression layerGate
Pull requestUnit regression and a UI smoke setBlocks merge
Merge to mainSelective or full regression, in parallelBlocks deploy to staging
NightlyComplete regression, long journeys, extra browsersTriaged next morning
Release candidateComplete regression on production-like dataBlocks release

Gates need enforcement. On GitHub, required status checks on a protected branch mean all required checks must pass before changes can be merged.

Flaky tests are the main threat to that trust. Playwright's retry reporting labels a test flaky when it failed on the first run but passed when retried. Track those, and fix them before people learn to ignore red builds.

What tools are used for regression testing?

Pick by layer and by who will maintain the tests.

CategoryExamplesBest for
Unit test runnersJest and equivalents in each languageFast unit regression on every commit
Code-based browser frameworksSelenium, Playwright, CypressEngineering teams who want full control in code
API and contract testingPostman CLI and Newman, PactBusiness rules and service contracts
Visual regressionPlaywright screenshot comparisonCatching unintended UI change
Performance regressionk6 thresholdsResponse-time and throughput budgets
AI and agentic platformsRobonitoTeams that want plain-language tests that keep working as the UI changes

Selenium describes itself as a browser automation tool for Chrome, Firefox, Edge and Safari. Playwright Test bundles a runner, assertions, isolation and parallelisation across Chromium, WebKit and Firefox. Postman now recommends the Postman CLI over Newman for CI, as Newman won't receive updates.

Regression testing with Robonito

Robonito is an agentic QA platform built for the part of regression testing that usually decays: keeping a large end-to-end suite current as the product changes.

  • Create tests in plain language, or let AI Studio generate them from requirement documents, Jira stories, Swagger/OpenAPI definitions or the live app.
  • Self-healing adapts steps when labels, layouts or locators change, and logs healed steps for review.
  • CI runs from Jenkins, GitHub Actions, GitLab CI or Azure DevOps on Starter and above, in parallel isolated cloud workers.
  • Evidence for every run: video, network traces and an AI root cause for failures, plus pass rates and trends across runs.

Club Car moved its CPQ and 3D configurator testing to Robonito and cut QA testing time by over 70%.

Where it doesn't fit: Robonito doesn't replace your unit tests, and it won't decide which journeys matter. Web testing is on every plan, but mobile, desktop and API testing need Pro or Enterprise. Exploratory regression stays with your testers.

See how it works on the automation testing tool page, read the Club Car case study and others, or .

Frequently asked questions

What is regression testing in simple terms?

It's checking that things which worked before a change still work after it. Whenever code, configuration or a dependency changes, you re-run tests on the existing features around that change, so a fix or new feature doesn't quietly break something users rely on.

What is the difference between regression testing and retesting?

Retesting confirms that a specific reported bug is now fixed, by re-running the test case that failed. Regression testing checks that the fix, or any other change, didn't break anything else. Teams usually do both: retest the bug, then run regression tests around the affected area.

What are the main types of regression testing?

Common types are unit, partial, selective, complete (retest-all), corrective and progressive regression. Corrective reuses existing tests when requirements haven't changed; progressive updates tests when they have. Visual and performance regression add screenshot comparisons and response-time thresholds on top of functional checks.

How do you automate regression testing?

Start with your highest-risk journeys, write each test around a user goal with a clear expected result, give tests their own data, and run them in parallel from your CI pipeline so failures block merges. Then manage flaky tests actively. Our automated regression testing guide covers each step.

Is manual regression testing still needed?

Yes, for a smaller share of the work. Exploratory sessions around risky changes, usability and visual judgement, one-off migrations and features still changing every sprint are better checked by people. The repeatable core of the suite should be automated so testers have time for that.

How often should regression tests run?

Run a fast smoke set on every pull request, a selective or full suite on every merge to main, a complete run nightly, and a full run on each release candidate. The more often the suite runs, the smaller the change behind each failure, and the cheaper the fix.


Stop finding regressions in production. to see your regression suite run in CI, or .

Free whitepaperThe Agentic QA PlaybookMove from test scripts to AI agents in 90 days, with the controls, metrics and a 25-question vendor checklist.

No-code AI test automation

Spend less time testing and more time shipping.

3Pillar showed Robonito's agents to its own client live, and that client is now onboarding. Start on the Free plan, which stays free forever, or book a demo and we'll walk through your own app.

All blog posts