Web app testing

What Is Regression Testing? Definition, Types, Examples and Checklist

Key takeaways

  • Regression testing re-runs your existing tests after a code change, to catch anything the change broke.

    It checks the features that already worked, not just the new one.

  • Run your regression suite on every pull request, so each failure points to one small change.

    Waiting for a release leaves you working out which of dozens of changes broke something.

  • Start with your critical user flows, and get them stable before you expand coverage.

    End-to-end tests can create a lot of noise and maintenance at first, so cover your P0 flows, then keep going until everything a user can do has a test.

  • Once a person has checked a new feature, automate its test and run the whole suite in parallel.

    Open frameworks like Playwright and Appium keep the tests yours, and running every test at once keeps the suite as fast as its longest test.

  • Budget for investigating failures and maintaining tests, which cost more over time than writing them.

    Without maintenance, about half of end-to-end tests need changes or removal within six weeks.

Regression testing is re-running tests on features that already work after a code change, to confirm the change didn't break them. A regression is a bug in something that used to work. You fix checkout on Monday, and on Wednesday the coupon field stops working, though nobody touched coupons.

Any change can cause one: a new feature, a bug fix, a dependency upgrade, a config or feature-flag change. A regression suite, the tests you've built up for features that already shipped, is how you find out before your users do. Teams that ship often automate their regression testing and run it on every pull request or deploy.

What is regression testing?

Regression testing checks that existing functionality still works after a change. The name comes from the bug it catches, where a feature goes backward from working in one release to broken in the next.

A regression suite (or regression test suite) is the collection of tests for features that already shipped, such as sign-up, login, search, checkout and the other flows your users rely on every day, so the tests themselves usually aren't new. When code changes, you run those tests again. If one fails, either the change broke something or the test needs updating, and someone has to work out which.

In practice, many teams use "regression testing" and "end-to-end testing" interchangeably. Their end-to-end suite, which tests those flows the way a user would, is the regression suite they re-run on every change.

For example, say your team adds a new payment method. The new feature gets its own tests. Regression testing is re-running the tests for card payments, refunds, discount codes and order history, to make sure the new payment method didn't break them.

Why is regression testing important?

Regression testing lets a team keep changing software without breaking what customers already use. Software is connected in ways nobody fully tracks. A change to a shared component, an API response, a database migration or a library upgrade can break a feature several layers away from the code you touched. Code review rarely catches that, because the reviewer reads the diff, and the diff doesn't show everything it can affect.

The faster you ship, the more this matters. More deploys mean more chances to break something, and less time for anyone to click through the app by hand. Even with good coverage, bugs keep coming. In QA Wolf's review of 50,000+ deploys, customers with comprehensive end-to-end coverage still had about 9 verified bugs for every 100 deploys tested in Q3 2026. Their tests caught most of those bugs before release.

Regression testing vs. retesting, smoke testing and sanity testing

Regression testing checks that a change didn't break anything that already worked. The kinds of testing it gets confused with each answer a narrower question. The table lists them in the order they run, from a feature being built to a release being signed off.

Question it answers Scope When it runs
Functional testing Does the feature do what the requirements say? Each feature, new or old While a feature is built, then again in every regression run
Smoke testing Is this build stable enough to test at all? A few health checks: the app starts and its services respond Right after each build or deploy, before the other tests
Sanity testing Does this one change or fix work? One feature or area After a small, targeted change
Retesting Is this specific bug fixed? The bug, or the test that failed After a fix, before the regression run
Regression testing Did this change break anything that used to work? Existing features, from the critical paths to the full suite After smoke tests and any retests, on every pull request, merge or deploy
User acceptance testing (UAT) Does the software meet the business's needs? Business workflows, checked by users or stakeholders Before a release is signed off

Smoke tests run first, because if the build won't start, there's no point running the regression suite. When you fix a bug, retest it, then run the regression suite to check the fix didn't break anything else.

Most regression tests are functional tests run again. Functional testing describes what a test checks; regression testing describes why and when it runs.

What are the types of regression testing?

There are seven commonly named types of regression testing. They differ in how much of the suite runs and why:

  • Corrective regression testing. The code changed but the requirements didn't (a refactor or a performance fix), so the existing tests run as they are.
  • Retest-all (complete) regression testing. Run the entire suite. It's the most thorough option, and realistic on every change only when the tests run in parallel.
  • Selective regression testing. Run only the tests tied to the code that changed, chosen by impact analysis. It's faster, but it misses regressions in places nobody expected the change to affect.
  • Prioritized regression testing. Run tests in order of risk: checkout, login and anything tied to revenue or compliance first, the rest after or less often.
  • Progressive regression testing. When requirements change, update and add tests so the suite matches how the product is meant to work now.
  • Partial regression testing. After a small, contained change, run the tests for the affected area plus the critical paths.
  • Unit regression testing. Re-run the unit tests for the changed code in isolation, usually on every commit, before integration and end-to-end tests run.

Regression testing also covers how the app looks and performs. Visual regression testing compares screenshots against an approved baseline, and performance regression testing fails a test when a page or workflow gets slower than its benchmark.

With every test running in parallel, the full suite can run on every pull request. Teams on sequential or sharded runs often mix types instead: a selective or prioritized run on every pull request, and the full suite nightly.

When should you run regression tests?

Run regression tests after every change that could affect existing behavior, as soon after the change as you can:

  • On every pull request or merge, triggered from your CI pipeline, so a failure points at one small change.
  • On every deploy to a test or staging environment.
  • After bug fixes, since a fix is a code change like any other.
  • After dependency, framework or infrastructure upgrades, which can break things without anyone touching your application code.
  • After configuration and feature-flag changes, which change behavior without a code deploy.
  • Before a major release, as a final full run.

In agile teams, regression testing runs inside every sprint, on each merge, so a sprint doesn't end with days of manual regression checks. If regression tests only run before a big release, every failure means working out which of the last 40 changes broke it, while running on every change keeps the answer obvious.

How do you choose which tests go in a regression suite?

QA Wolf's position is that anything a user can do should get a test. Teams used to pick carefully, because every test added to the run time on sequential or sharded runs, and someone had to maintain it by hand. With AI agents maintaining the tests and every test running in parallel, an extra test costs little, so the suite should cover the whole product.

Build it up in order of what would hurt most if it broke:

  • Critical user flows first: sign-up, login, checkout, payments and the core workflow your product exists for. Get these stable before you expand.
  • Revenue and compliance paths: billing, permissions, data exports and anything with contractual or legal weight.
  • Places that have broken before: every bug that reaches production gets a test, so it can't come back unnoticed.
  • Integrations: payment providers, authentication, email and third-party APIs, where a change on either side breaks things.
  • Complex flows with many steps or states: they're the hardest to check by hand and the likeliest to break in ways code review misses.
  • Then everything else a user can do: settings, roles, edge cases and the features fewer people use, until every flow has a test.

Leave out only tests for retired features and near-duplicates. Run the whole suite on every pull request, since in parallel it takes about as long as its longest test.

How do you do regression testing?

Regression testing follows the same loop after every change: find what the change touches, run the right tests, and act on every failure.

  1. Work out what the change touches: the code in the diff, plus shared components, APIs and data that depend on it.
  2. Run the full suite, or, if your runs aren't parallel yet, the critical paths and the tests for affected areas, with everything on each deploy.
  3. Run the tests automatically, from CI, in parallel, so results come back while the change is still fresh.
  4. Investigate every failure quickly. A failed test is either a real bug or a test that needs updating. Somebody has to decide which, fast, or failures pile up and people stop trusting the suite.
  5. Report bugs with evidence: steps to reproduce, expected and actual results, logs and a recording. Retest once the fix lands.
  6. Update the suite: fix tests for intended changes, delete tests for removed features, and add a test for every escaped bug.

What is an example of a regression test?

A regression test re-checks a feature that already worked, such as applying a discount code at checkout, every time the code around it changes.

Here's a small regression suite for a cart's discount code, written in Playwright. It checks that a valid code lowers the total and an invalid one doesn't, so a later change to pricing or checkout can't break discounts without anyone noticing. Each test follows Arrange-Act-Assert: set up the cart, do one thing, then check the result. The tag lets CI run only the regression suite with npx playwright test --grep @regression.

import { test, expect } from '@playwright/test';

test.describe('cart discounts', {
  tag: '@regression',
}, () => {
  test('a valid code lowers the total', async ({
    page,
  }) => {
    // Arrange: open a cart that totals $100.00
    await page.goto('/cart');

    // Act: apply a valid discount code
    await page
      .getByLabel('Discount code')
      .fill('SAVE10');
    await page
      .getByRole('button', { name: 'Apply' })
      .click();

    // Assert: the code is accepted and 10% comes off
    await expect(page.getByRole('alert'))
      .toHaveText('Code applied');
    await expect(page.getByTestId('total'))
      .toHaveText('$90.00');
  });

  test('an invalid code is ignored', async ({
    page,
  }) => {
    // Arrange: open a cart that totals $100.00
    await page.goto('/cart');

    // Act: apply a code that doesn't exist
    await page
      .getByLabel('Discount code')
      .fill('NOTACODE');
    await page
      .getByRole('button', { name: 'Apply' })
      .click();

    // Assert: the code is rejected and the total stays the same
    await expect(page.getByRole('alert'))
      .toHaveText('Invalid code');
    await expect(page.getByTestId('total'))
      .toHaveText('$100.00');
  });
});

The second test shows why a regression suite has to check that things that shouldn't change didn't, as well as checking the happy path. If a pricing change starts accepting any code, the first test still passes and the second one catches it.

Manual vs. automated regression testing: which should you use?

Automated, for anything you check on every change. A person checks a new feature first, for usability and the judgment calls a script can't make, and then the team builds an automated regression test for it, so every later change is checked against it.

Manual regression testing means a person clicks through the app after each change, usually from a checklist. It works for a small app with infrequent releases. But it's slow, it gets skipped under deadline pressure, and people miss things on the fortieth run of the same checklist.

Lifesum is a perfect example. Before automating, its manual tester spent two full days on hundreds of regression tests before each mobile release, and the team estimated only about half of its workflows were fully tested. "Now we do full regression testing in less than a day," says its Head of Technology.

Automated regression testing runs the same checks in code, as often as you want. It's the only option that keeps up when you deploy several times a day. The catch is that automated tests are software too, so someone has to write them, run them, investigate failures and keep them working as the product changes.

How do you automate regression testing?

To automate regression testing, write end-to-end tests for every flow a user can take, critical ones first, in a framework like Playwright or Appium, run them in parallel from your CI pipeline on every pull request, and give someone the job of investigating failures and maintaining the tests.

  • Pick a framework your team can own. Open-source frameworks keep your tests as code you can read and run anywhere, such as Playwright for web apps and Appium for iOS and Android. Mobile suites add a scale problem of their own, since each phone or emulator runs one test at a time, covered in QA Wolf's guide to automated mobile regression testing. Low-code and record-and-playback tools are quicker to start, but check who maintains the tests and whether you can export them. Salesloft tried no-code tools first and found them hard to maintain, with lots of flaky tests.
  • Write tests that can run in any order. When each test sets up and cleans up its own data, the suite can run in parallel and finish in about the time of its longest test.
  • Trigger runs from CI. Run on every pull request against a preview environment and on every deploy to staging, and require a passing run before merging or releasing.
  • Decide who triages failures. Every failure needs a verdict fast. Flaky tests that pass on retry need tracking too, or people learn to ignore red builds.
  • Plan for maintenance. Tests break when the product changes on purpose, and someone has to update them before they block a release.

AI now helps with the recurring parts: picking the tests a change affects, updating tests when the UI moves, and sorting failures into bugs, broken tests and flakes. Many AI testing tools claim some of this. Ask each one how it proves a fix works, because a tool that can edit assertions can turn almost any test green.

Or let QA Wolf's AI agents build, run and maintain the suite for you.

Why do regression suites break down?

Writing the tests is the easy part, and the recurring work of investigating failures and maintaining tests is what sinks most regression suites. Before AI agents took on the work, QA Wolf measured how long each stage took its QA engineers across 3.5 million tests in more than 100 apps. Creating a test took about 95 minutes, once. Investigating a failure took about 17 minutes, fixing a broken test about 45 and reporting a bug about 30, and those came back every time the team shipped. AI agents do this work faster now, but investigation and maintenance still take more of the work than writing the tests.

Without ongoing maintenance, tests decay fast. QA Wolf benchmarks show that about half of end-to-end tests need to be changed or removed within six weeks. Then flaky tests creep in, developers re-run failures until they pass, and the suite stops being a signal anyone trusts.

So the deciding question for a regression suite is who keeps it running and trustworthy as you ship more.

How does QA Wolf run regression suites?

QA Wolf's AI agents build, run and maintain end-to-end regression suites on QA Wolf's own web and mobile testing infrastructure, so the full suite runs on every pull request without your engineers babysitting it. From QA Wolf's docs and engineering posts:

  • Tests are written for you, as code you own. QA Wolf's AI agents write Playwright and Appium tests, starting with your highest-priority flows and then the most complex ones. You own the code and can review, change and version it like any other code.
  • The full suite runs in parallel. Every test gets its own container, so a run takes about as long as its longest test, whether the suite has 200 tests or 20,000.
  • It runs on every pull request. PR testing runs your tests against each pull request's preview deploy and posts the result as a check on the pull request, which branch protection can require before a merge. Suites also run on deploys and on a schedule.
  • Failures are investigated before they reach you. A failing test is retried, then QA Wolf's AI starts investigating while the rest of the suite is still running, sorting each failure into a product bug, an out-of-date test or a flake. Out-of-date tests are fixed and re-run. Real bugs are reported to you with a recording, logs and steps, in Slack or Teams and your issue tracker. When an agent needs a question answered, such as whether a change was intended, it asks you.
  • The agents maintain the tests. When your product changes, they update the tests it breaks, so the suite keeps passing.

In QA Wolf's data on 127 recurring suites, such as a team's daily regression run, the median time from every test having run to every failure having a conclusion fell from 2.3 hours with human investigation to 21 minutes with AI investigation (data through Oct 15, 2026).

Median time to triage · 127 recurring suites

  • Human investigation386 runs2.3 h
  • AI investigation443 runs21 min
Triage time runs from the moment every test in a suite has run once until every failure in it has a conclusion. Counting suites still under investigation as open, the AI median is 41 minutes. Data through Oct 15, 2026.

Salesloft runs 2,000 automated tests with QA Wolf, 300+ of them in parallel on every PR, and estimates it would take up to seven full-time QA engineers to do the same work. That saves it more than $750K a year in QA engineering. Start now and ask the agent to build your regression suite, starting with your critical flows, or talk to sales.

Regression testing checklist

Use it to set up a regression suite, or to check the one you have:

  • Every flow a user can take has an automated test, starting with the critical ones (sign-up, login, payments, your core workflow).
  • Every bug that reached production has a test.
  • Tests are independent: each sets up and cleans up its own data.
  • Smoke checks run first, and a failure stops the pipeline.
  • The full suite runs in parallel on every pull request.
  • The suite finishes fast enough that nobody skips it.
  • Every failure gets a verdict, a bug to file or a test to fix, before the next run.
  • Flaky tests are tracked and fixed; re-running until green doesn't count.
  • Tests for intended changes are updated in the same sprint, and tests for removed features are deleted.
  • Bug reports include steps, expected and actual results, logs and a recording.
  • Investigation and maintenance have a named owner.
  • The tests are code your team can read, run and export.

Frequently asked questions

  • What is meant by regression testing?

    Regression testing means re-running tests on features that already worked after a code change, to make sure the change didn't break them. A "regression" is a bug in something that used to work.

  • What is an example of a regression test?

    After a team adds a new payment method, re-running the existing tests for card payments, refunds and discount codes is regression testing. A single regression test might apply a valid discount code and check the total drops, then apply an invalid one and check the total stays the same.

  • What is regression testing used to test?

    It tests existing functionality, such as the login, search and checkout flows users already rely on. It catches side effects of new features, bug fixes, dependency upgrades and configuration changes.

  • What is the main purpose of regression testing?

    Its purpose is to let a team keep changing software without breaking what already works. Running the regression suite after each change catches those breaks in testing, before users find them.

  • What is a regression test suite?

    A regression test suite is the collection of tests for features that already shipped, re-run after each change. It starts with the critical user flows and grows until everything a user can do has a test, plus a test for every bug that reaches production.

  • Is regression testing a type of functional testing?

    Mostly, yes. Most regression tests are functional tests run again after a change, to check that features still do what they should. Regression testing can also re-run non-functional checks, such as visual comparisons or performance benchmarks.

  • What's the difference between regression testing and retesting?

    Retesting checks that a specific bug is fixed. Regression testing checks that the fix, or any other change, didn't break something else. Teams usually retest the bug and then run the regression suite.

  • What's the difference between regression testing and UAT?

    User acceptance testing (UAT) is when business users or customers confirm the software does what they need before release, while regression testing checks that changes didn't break existing features.

  • When is regression testing done?

    After any change that could affect existing behavior: new features, bug fixes, dependency upgrades and configuration changes. Teams that ship often run it automatically on every pull request or deploy, plus a full run before major releases.

  • What is regression testing in agile?

    In agile teams, regression testing runs inside every sprint, on each merge or deploy, so each sprint's changes are checked as they land. That only works with an automated suite, because a manual regression pass every sprint takes days.

  • Who does regression testing?

    QA engineers, SDETs and developers, depending on the team. Developers usually own unit regression tests, and QA engineers own the end-to-end regression suite, unless QA Wolf builds and maintains it for them.

  • Is regression testing manual or automated?

    It can be either. Manual regression testing works for small apps that release rarely, but teams that ship often automate it so the suite can run on every change. A person still checks each new feature first, for usability and what a script can't judge, and then the team adds an automated test for it.

More from the blog

All posts