Types of software tests: which ones your app needs
A type of software test is a name for the question a check answers: "does the app start at all?" is a smoke test, "did my fix work?" is a sanity test, and "did my change break something that used to work?" is a regression test. A small web app needs three of them from the first day: a smoke test after every deploy, a regression suite on the journeys people pay for, and an hour of exploratory testing before each launch.
The examples use one app: Ledgerly, an invented invoicing app for freelancers. A freelancer signs up, adds a client, creates an invoice and emails it. The client opens a link and pays by card through a payment provider, and the invoice turns to Paid.
Which test answers which question#
| The question you have | The test that answers it | When it runs |
|---|---|---|
| Is the app up, and can anyone sign in? | Smoke test | After every deploy |
| Did my fix work? | Sanity test | Right after the fix |
| Did my change break something that worked yesterday? | Regression test | Before every release, and on a schedule |
| Does this feature do what I said it should? | Functional test | When the feature is built or changed |
| Can a person get from the first page to the outcome? | End-to-end test | After every deploy |
| Do my app and the services it calls agree? | Integration test | When either side changes |
| Does this one function return the right value? | Unit test | On every save or commit |
| Does the page still look right? | Visual regression test | After every change to styles or layout |
| What is broken that nobody thought to check? | Exploratory testing | Before a launch and after a large change |
| Is this what the customer asked for? | User acceptance testing | Before hand-over or release |
| Does it work on a phone and a slow connection? | Screen size and network checks | Before a launch, then with the regression suite |
The names overlap. One check can be an end-to-end test by how it runs, a functional test by what it checks, and a regression test by why you keep it.
What is a smoke test?#
A smoke test is a short set of checks that the most important paths of an app work at all, run on every new build before any other testing.
For Ledgerly, the smoke test is four checks: the home page loads, a test account can sign in, the invoice list shows, and the New invoice form opens. It does not check totals, emails or payments.
Run it after every deploy, and keep it under a few minutes. A script should run it, because a person forgets on the third deploy of the day. Skip it and you learn that sign-in is down from a customer, hours after the deploy that caused it. The smoke test template has six worked rows to start from.
What is a sanity test?#
A sanity test is a narrow check that one fix or one small change works, together with the things right beside it.
Say Ledgerly applied tax twice on invoices with a discount, and you fixed it. The sanity test creates an invoice with a discount and reads the tax line, then tries one with no discount and one with a 100% discount. It stays on that one screen.
Run it as soon as the fix is deployed, before anyone spends time on a wider pass. The person who made the fix, or the person who reported the bug, usually runs it by hand. Skip it and the customer is told the bug is fixed, opens the app and finds it again. The sanity test template lays out the rows, and smoke vs sanity vs regression testing follows one release through all three.
What is a regression test?#
A regression test re-checks a feature that already worked, so a new change does not break it unnoticed.
Ledgerly's regression suite covers what freelancers rely on: creating an invoice, editing it, emailing it, the client paying it, and the monthly total on the dashboard. None of those was meant to change in the tax fix, and the fix touched the function that also formats the dashboard total.
Run the suite before every release, after every deploy and on a schedule against production. It is the first thing to automate, because the steps are the same every time and people stop running a long list by hand. Skip it and the same bugs come back, each one found by a customer. Start from the regression test template, and read regression testing for AI-generated code if a coding agent writes most of your changes.
What is a functional test?#
A functional test checks that a feature does what its requirement says, one behaviour at a time, including what happens when the input is wrong.
Ledgerly's requirement says an invoice needs a client, at least one line and a due date that is not in the past. The functional tests are one check per behaviour: a valid invoice saves, an invoice with no lines is refused with a message, and a due date of yesterday is refused.
Write them when the feature is built and run them again whenever it changes. A person can run them from a sheet, or a script can run them through the page. Skip them and the normal path works while the refusals do not, so the first customer to leave a field blank finds the bug. The functional test template ties each row to its requirement.
What is an end-to-end test?#
An end-to-end test drives the whole app the way a person does, through the browser, from the first page to an outcome the person came for.
For Ledgerly: sign in, create an invoice for a client, email it, open the pay link as the client, pay with the provider's test card, and see the invoice marked Paid. That one test crosses the pages, the server, the database, the email service and the payment provider.
Run end-to-end tests after every deploy and on a schedule. A browser automation tool runs them, such as Playwright, or a product that writes and runs the tests for you. Skip them and every part can pass its own tests while the journey fails at a join between two of them. End-to-end tests are slower than unit tests, so keep them to the journeys that matter and let cheaper tests cover the details.
What is an integration test?#
An integration test checks that two or more parts work together: your code and your database, or your app and a payment provider, an email service or another API.
In Ledgerly, the payment provider calls back when a client pays. The integration test sends that callback in the provider's test mode and checks that the invoice becomes Paid, that it does so only once when the callback arrives twice, and that a declined card leaves it Unpaid.
Run integration tests when either side changes, and on a schedule, because the other side can change without telling you. Developers write them in code, beside the app, and they run in CI. Skip them and money moves at the provider while your app records nothing. The integration test template covers the manual version, with a column for the test data each row needs.
What is a unit test?#
A unit test checks one function or one component on its own, with everything around it replaced by fixed inputs.
Ledgerly has a function that turns line items, a discount and a tax rate into a total. Its unit tests feed it numbers and compare the result, rounding included.
Unit tests are fast enough to run on every save or commit, and the developer or the coding agent that wrote the function writes them. Skip them and a wrong total is found through the page, slowly, by a test that cannot say which line was wrong. Unit tests say nothing about whether the Save button calls that function, so an app needs them and at least one test that goes through the page.
What is a visual regression test?#
A visual regression test compares a screenshot of a page with an approved one and reports what changed.
A CSS change in Ledgerly pushes the Send invoice button under the footer at tablet width. Every functional check still passes, because the button exists and a script can click it. The screenshot comparison shows it.
Run visual checks with the regression suite, and have a person approve each new baseline from a run they have looked at. Skip them and layout breaks ship until a customer sends a screenshot. Visual checks are noisy when baselines and runs come from different machines; visual regression testing without the noise covers how to avoid that.
What is exploratory testing?#
Exploratory testing is a person using the app with no script, following what looks odd, and writing down what they find.
An hour in Ledgerly as a new freelancer turns up an empty invoice list with no hint of what to do next, a second account that can open the first account's invoice by changing the number in the address, and a client name of 200 characters that breaks the PDF.
Do it before a launch and after any large change. A person does it, ideally one who did not build the feature. Skip it and the only bugs you find are the ones you already thought to test for. How to test a vibe-coded app before launch is a guided first session, and bug reports developers can act on covers how to write up what you find.
What is user acceptance testing (UAT)?#
User acceptance testing is the customer, or someone standing in for them, using the finished feature to decide whether it is what they asked for.
Ledgerly passes every test for recurring invoices, and then a freelancer tries it and says they bill on the last working day of the month, which the feature cannot do. No test failed, and the feature has to change.
Run UAT before you hand work to a client or release a feature people asked for. The client, a few customers or a colleague outside the team does it, on a staging copy of the app, with a short list of things to try and an easy way to report what they see. Skip it and you learn what was wanted after release, when changing it costs a second release.
How do I check different screen sizes and slow networks?#
Screen size and network checks run the same journeys at phone and tablet widths and on a throttled connection.
At 390 pixels wide, Ledgerly's invoice table pushes the Pay button off the screen. On a slow connection, the client taps Pay twice while the first request is still in flight, and is charged twice.
Check by hand before a launch using your browser's device toolbar and network throttling, then add the sizes and speeds your customers use to the automated runs. Emulation in a desktop browser shows layout and timing problems. It does not show everything a phone in someone's hand does, so open the app on your own phone as well. Skip these checks and layout and double-payment bugs reach every customer who opens the app on a phone.
If you only do three things#
A solo developer with no time for eleven kinds of testing should do these, in this order.
- Smoke test after every deploy. Three to five checks: the app loads, sign-in works, the main page shows, the main form opens.
- Automate the three journeys you would lose money on. For Ledgerly: sign up, create and send an invoice, get paid. Run them end to end after every deploy and once a night. Those three tests are your regression suite.
- Explore for an hour before each launch. Use a new account, a second account, bad input and a phone. Turn each bug you fix into one more regression test.
Add unit tests where there is arithmetic or rules, integration tests where money or email crosses to another service, visual checks once a layout bug has reached a customer, and UAT when you build for a client. The test case template workbook gives you a sheet for each manual list, and the bug-to-fix loop covers what happens after a test or a person finds a bug.
What FlowQA and Snag do, and what they do not#
TestFinch makes FlowQA and Snag.
FlowQA writes and runs end-to-end tests. Its AI agent explores your web app and writes tests in plain steps. You can also record a test by hand in FlowQA Desktop, or have a coding agent write one. A suite of a few tests run after every deploy is your smoke test. All of them, run on a schedule, from CI or on GitHub deployments, are your regression suite. Each test checks behaviour through the page, so it also does the work of a functional test for the cases it covers. FlowQA runs tests on Chromium at desktop sizes and at tablet and Android phone sizes emulated in Chromium, on throttled Fast 4G, Slow 4G and 3G networks, and keeps visual baselines for each screen size. When a page changes on purpose, FlowQA proposes a repair and a person approves it. A bug filed in Snag can become a test, so the sanity check for a fix stays on as a regression test.
FlowQA does not write unit tests or integration tests in your code. It drives a browser and does not read or run your functions. It emulates phones and tablets in Chromium and does not run other browser engines or native mobile apps. Its exploration plans and writes tests, and does not replace a person's exploratory session or a customer's acceptance testing.
Snag is for the testing people do by hand. During exploratory testing, a sanity check or UAT, Snag's Chrome extension files what the person found with a marked-up screenshot or a recording, the last steps, the console errors and the failed requests. A client can report as a reporter, who files bugs and sees only their own. Snag runs no tests.
FlowQA's free plan covers 1 project, up to 100 tests and 1,000 cloud test runs a month, with no card. Create your first regression test with FlowQA walks through it, and Coding agents shows how Claude Code, Codex or Cursor writes and runs the tests from your terminal.
Common questions#
What is the difference between smoke testing and sanity testing?#
A smoke test is broad and shallow: it checks that the main paths of the whole app work at all after a new build. A sanity test is narrow and deeper: it checks that one fix or change works, with the things beside it. Not every team draws that line: the ISTQB glossary, read on 18 November 2026, defines smoke testing and has no entry for sanity testing, and some testers use the two names for the same quick check of a build.
What is the difference between sanity testing and regression testing?#
A sanity test looks at the thing that changed. A regression test looks at everything that was not supposed to change. After a fix, run the sanity test first, because a regression run on a build whose fix does not work is wasted.
Do I need all of these types of tests?#
No. A small app is well served by a smoke test, an automated regression suite on its main journeys and regular exploratory testing. Add each other type when you meet the problem it answers.
How many tests are enough?#
Enough that you would deploy on a Friday without checking by hand. Start with three to five end-to-end journeys and add one test for each bug that reaches a customer. Keep the suite short enough to finish before you would otherwise have moved on to the next change.
Can an AI write my tests?#
Yes, with one condition: check that each test can fail. A coding agent can write a test that passes while checking nothing, so break the page on purpose and watch the test go red, then read what it checks. How to test what Claude Code wrote before you merge it shows how.
Should tests be manual or automated?#
Automate what repeats: smoke, regression and end-to-end tests run the same steps every time. Keep by hand what needs judgement: exploratory testing, UAT and the first sanity check of a fix. A manual test you have run three times the same way is ready to automate.