Smoke testing in software testing is a short set of checks you run on every new build or deploy to find out whether it works well enough to test any further. It covers the handful of flows that must never break, such as signing up, logging in and paying. It runs in minutes, and a failure stops the release instead of starting a long investigation.
The hard part is keeping it small, and that's where most of this piece goes.
Why it's called smoke testing
Plumbers pushed smoke through pipes to find leaks long before software existed, and electronics engineers later borrowed the term for the first power-on of a new board. If it smoked, you stopped.
The best-known early description in software is Steve McConnell's 1996 IEEE Software column Daily Build and Smoke Test. He describes a smoke test as "a relatively simple check to see whether the product 'smokes' when it runs", run every day against the fresh daily build. Without it, he argues, a daily build only proves the code compiled.
He also saw the catch. As the system grows, McConnell writes, the smoke test "can grow to 30 minutes, an hour, or more".
What a smoke test checks: smoke testing examples
A smoke test asks whether this build is alive on the paths that matter, meaning a user can get through the core of the product end to end. Edge cases, error messages and layout are left for later testing.
For a typical SaaS product, the list looks something like this:
- The app loads and the login page renders.
- A new user can sign up and reach the first screen.
- An existing user can log in.
- The user can create the product's core object, whether that's a project, an invoice or a report.
- The billing or upgrade page loads and accepts a test card.
An online shop's version swaps the middle items for search, product page, add to cart and checkout with a test payment. Both lists are illustrations. Yours should come from one question: if this broke for an hour, would customers notice, and would it cost money?
Each check should be a full user flow in the running app. Unit tests belong earlier in the pipeline. A green unit test suite tells you the functions behave, but not whether the deploy wired them together.
Smoke testing vs sanity testing vs regression testing
These three get mixed up in standups, so it helps to put them side by side.
| What it checks | When it runs | Size | |
|---|---|---|---|
| Smoke testing | The build works on the critical paths | Every build or deploy | A few to a few dozen flows |
| Sanity testing | One fix or small change works as intended | After a targeted fix | A handful of checks around the change |
| Regression testing | Things that already worked still work | Before a release, nightly, or per change | Dozens to thousands |
Put simply, smoke is broad and shallow, sanity is narrow and a bit deeper, and regression covers everything that already worked. Smoke vs sanity testing goes deeper on the first pair, and what regression testing is covers the third.
User acceptance testing sits elsewhere again. UAT asks whether the feature does what the business asked for, and the people who asked for the feature are the ones who sign it off. A smoke test asks whether the build runs at all.
When to run smoke tests
Whenever a new build lands somewhere people or other tests depend on: staging, production, and on a timer.
After a deploy to staging. This is the classic slot. If staging is broken, every test and every manual check that follows is wasted, so the smoke run goes first and gates the rest.
After a production deploy. In the customer calls we went back through for this piece, about eight teams described the same routine after a staging deploy or go-live: one or two QA people spending around half an hour clicking through the main flows by hand. What they wanted instead was a plain go or no-go.
On a schedule. A nightly run catches drift from things that didn't come through your pipeline, such as an expired certificate, a changed third-party API or a feature flag someone flipped.
Smoke testing in production
Running smoke tests in production needs care. Use dedicated test accounts, test-mode payments and data you can throw away, and keep the checks read-mostly where you can. Whatever runs the checks, a script or an agent, will at some point click something you didn't expect, so plan for it.
Manual or automated?
A manual smoke checklist is a reasonable place to start. It's cheap, anyone can run it, and writing it forces the team to agree on what "critical" means.
It stops working when releases speed up. Half an hour per deploy is fine once a week. At several deploys a day, the checklist gets skipped or rushed, and that's exactly when something slips through. Automating it is the obvious move, and a small suite of end-to-end tests running from your pipeline after each deploy covers it.
Automated suites have their own failure mode, though. A scripted smoke test that clicks a button by its CSS selector breaks when the button moves, even though the flow still works. Fix enough of those and people stop trusting the run, which defeats the point of a gate.
How small should a smoke suite be?
Our rule of thumb is to keep it under about 50 tests, with 100 as a hard ceiling. If your smoke suite takes more than a few minutes, it's turning into a regression suite with a different name.
Suites grow because every incident adds a test and nobody ever removes one. Daniel Mauno Pettersson, our co-founder and CEO, describes the pattern: a team makes a push and writes a load of tests, they deteriorate because nobody looks after them, and a while later the team makes another push.
His answer is to split the work by how often something needs checking. When the sign-up flow changes, the first test of it might be worth running for every country you sell in. Running that same sweep on every deploy, forever, gets too slow and too expensive, especially with AI doing the testing. So you test deeply around the change once and keep the always-on part short.
That gives you two layers:
- A short smoke suite that runs on every deploy and never changes much: sign up, log in, the core action, pay.
- Deeper checks scoped to each change, run on the pull request against a preview environment and thrown away afterwards. This is what we call dynamic testing.
The smoke suite can stay small because of the second layer. If every change is tested in depth before it merges, the smoke run only has to prove the deploy itself worked. We make the longer case in why a large regression suite is a liability.
Running smoke tests with AI agents
Using an agent changes how you write the suite, though the list of flows stays as it was. You describe each flow as a goal ("sign up with a new email and reach the dashboard") instead of a script of selectors, and an agent works out the clicks against the live app. A moved button is far less likely to fail the run, and a broken flow still does.
An agent-run smoke check has blind spots of its own. It only drives Chromium, so a failure that shows up only in Safari or Firefox passes. It works from the UI, which means a backend exception behind a normal-looking page goes unnoticed, and Sentry or whatever error monitoring you run still has a job. It can't write test data straight into your database either, so it needs a sign-up flow or an API to create its accounts, and it doesn't automatically clean up the data it creates, which matters if you smoke test in production.
In QA.tech, an AI testing platform, the smoke suite is a test plan. You can start it from GitHub Actions or GitLab CI after a deploy, from any other pipeline through the API, or on a cron schedule. When the run finishes, a regression review agent investigates every test that didn't pass, reruns the ones that look flaky, and writes one verdict: what works, what's broken and what it couldn't verify. That gives you the go or no-go signal described earlier.
FAQ
What is smoke testing in simple terms? It's a quick check that a new version of your software basically works before anyone spends time testing it properly. You run the most important user flows, such as logging in and paying, and if any of them fail, the build goes back.
Why is it called smoke testing? The term comes from plumbing and hardware, where you checked for smoke when you first ran something new. In software, the best-known early write-up is Steve McConnell's 1996 article on daily builds, which describes it as a simple check of whether the product "smokes" when it runs.
What is the difference between smoke testing and sanity testing? Smoke testing checks that a whole build works on its critical paths, and it runs on every build. Sanity testing checks that one specific fix or change works, and it runs after that change.
What is the difference between smoke testing and regression testing? A smoke test checks a few critical flows to decide whether a build is worth testing at all. A regression test checks that existing features still work after a change, and it covers far more of the product. Smoke runs first and gates the regression run.
How many tests should a smoke suite have? As few as cover the flows that must never break. Our rule of thumb is under about 50 tests, and it should finish in minutes. If it keeps growing, move the extra checks into per-change testing instead.
Can you run smoke tests in production? Yes, and right after a release is a good time for it. Use dedicated test accounts, test-mode payments and disposable data, and avoid checks that change real customer records.
Who does smoke testing? Whoever owns the release. On the calls we reviewed for this piece, it was one or two QA people running a manual checklist after the deploy. Teams without dedicated QA can trigger an automated suite from the deploy pipeline and have the developers who shipped the change read the result.
