What is smoke testing in software development? It is the first quick look at a fresh build: a handful of checks that answer one question, “is this build stable enough to be worth testing at all?” If the application will not start, the login page throws an error or checkout never completes, there is no point running a two-hour regression suite. The smoke test catches that in minutes and sends the build straight back to the developers.
Smoke tests are a small but load-bearing part of any serious software testing services setup. They sit between developer-owned unit tests and the slower functional, regression and end-to-end suites, and they act as the gate that decides whether those slower suites run. Teams that skip this gate tend to discover broken builds the expensive way, after testers or customers have already lost time on them.
This guide covers the definition, where the term comes from, how a smoke test differs from a build verification test, sanity testing and regression testing, when to run one, a step-by-step process, a sample smoke test checklist, CI/CD setup with a pipeline example, tools for 2026, advantages and limitations, and the best practices that keep a smoke suite fast and trusted.
What is smoke testing in software development?
Smoke testing is a shallow, wide check of a new software build that verifies its most important functions work, so the team can decide whether to accept the build for further testing or reject it. It does not try to find every bug. It tries to find the bugs that make every other test pointless.
The ISTQB Glossary, the reference vocabulary used by software testers worldwide, defines a smoke test as “a test suite that covers the main functionality of a component or system to determine whether it works properly before planned testing begins.” Three ideas in that definition matter in practice:
- Main functionality only. A smoke test covers the critical paths, such as launching the app, signing in, loading the main screen and completing the core transaction. Edge cases are left for later.
- Breadth over depth. It touches many areas of the system lightly instead of exploring one area thoroughly.
- Before planned testing. It runs first, as an entry criterion. A failed smoke test stops the pipeline; a passed one opens the door to functional, regression and performance testing.
The result of a smoke test is binary: the build either “passes smoke” and moves on, or “fails smoke” and goes back to development. That simple outcome is why smoke tests are so easy to automate and so useful as a gate.
What is a smoke test in software development, in plain terms?
In plain terms, a smoke test in software development is a fast health check of a new build. Think of a car mechanic who turns the key, checks that the engine starts, the lights come on and the brakes respond before booking the car in for a full inspection. Nobody runs a full inspection on a car that will not start, and nobody should run a full test cycle on a build that will not start either.
Where does the term “smoke test” come from?
The term comes from hardware and plumbing, long before software. Electronics engineers powered up a newly assembled circuit board for the first time and watched for smoke: no smoke meant the board was at least safe to test properly. Plumbers pumped harmless smoke through a new pipe system to see where it leaked out.
Software borrowed the idea in the 1990s. Steve McConnell’s article “Daily Build and Smoke Test”, published in IEEE Software in July 1996, described it as “a common practice at Microsoft and some other shrink-wrap software companies.” In that process, the whole product was compiled every day and then given a relatively simple check to see whether it “smokes” when it runs. McConnell used the Windows NT 3.0 project as an example: about 5.6 million lines of code in 40,000 source files, where a full build could take up to 19 hours, and a four-person build team still ran the daily build and smoke test.
The principle has not changed since then. What has changed is speed: a 2026 pipeline builds and smoke-tests a web application in minutes, on every merge, instead of once a night.
Smoke testing vs build verification testing: are they the same?
Yes, in most teams smoke testing and build verification testing (BVT) mean the same thing: a set of checks that decides whether a new build is good enough to test. The only nuance is emphasis. “BVT” stresses that the check is automated and runs on every build; “smoke test” is the broader everyday term.
The ISTQB Glossary defines a build verification test as “an automated test that validates the integrity of each new build and verifies its key/core functionality, stability, and testability.” Compare that with the smoke test definition above and the overlap is obvious. Other names you may meet for the same idea are intake test, confidence test and build acceptance test.
Why sanity testing is sometimes called a smoke test
Terminology varies between sources, and that confuses many teams. The ISTQB Glossary lists sanity test, intake test and confidence test as synonyms of smoke test. Most practitioners and tool vendors, however, use “sanity test” for something narrower: a quick check of one specific fix or feature after a minor change. This guide follows the practitioner usage and compares the two in detail below. Whatever words your team chooses, agree on them in your test strategy so “the smoke failed” means the same thing to everyone.
Why is smoke testing important?
Smoke testing is important because it stops broken builds at the cheapest possible moment, before testers, staging environments and customers spend time on them. A five-minute check that rejects a bad build can save a QA team a full day of investigation and a release team an emergency rollback.
The cost of late defects is well documented. NIST’s Planning Report 02-3 (2002) estimated that inadequate software testing infrastructure cost the US economy about $59.5 billion a year, with roughly $22.2 billion of that avoidable through earlier and better testing. Smoke tests do not replace thorough testing, but they are one of the cheapest ways to move defect detection earlier.
In day-to-day work, a reliable smoke suite gives a team:
- A clear go or no-go signal. Nobody argues about whether a build is testable; the gate decides.
- Protected QA time. Testers start every cycle on a build that is known to launch and complete its core flow.
- Faster feedback to developers. A broken merge is reported within minutes, while the change is still fresh.
- Safer deployments. Post-deployment smoke checks catch configuration and environment errors that never show up in unit tests.
- A visible quality baseline. A smoke pass rate over time shows whether the main branch is getting more or less stable.
It is also a direct application of the shift-left approach: run the most important checks as early and as often as possible.
When should you run smoke tests?
Run a smoke test every time the software changes in a way that could break its basic operation: on every new build, before any planned test cycle, and right after every deployment. In a CI/CD pipeline that usually means several times a day. Typical triggers include:
- A new build is produced, whether from a merge to the main branch or a nightly build.
- Before functional or regression testing begins, as the entry criterion for the QA cycle.
- After deployment to a test or staging environment, to confirm the environment, configuration and data are wired correctly.
- Immediately after a production release, as a post-deployment check of live critical paths.
- After infrastructure changes, such as a database upgrade, a new cloud region, a certificate rotation or a dependency bump.
- After a hotfix, to confirm the fix did not break startup or the core flow.
The staging step deserves special attention: a build can pass every test on a developer machine and still fail in an environment with different secrets, feature flags or data. Our guide to staging in software development explains how to keep that environment close enough to production for smoke results to mean something.
Who performs smoke testing?
Smoke testing is usually owned by the QA or test automation engineers who design the suite, but in modern teams it runs automatically and the whole team acts on the result. Who actually runs it depends on the team’s maturity:
- QA engineers choose the critical paths, write the smoke test cases and keep the suite healthy.
- Developers run the suite locally before pushing and fix a failed smoke immediately, because it blocks everyone.
- DevOps or platform engineers wire the suite into the CI/CD pipeline and the post-deployment checks.
- Release managers treat a passed smoke as a required condition for promoting a build.
In small teams without dedicated testers, developers own the whole process. That works, as long as someone is explicitly responsible for keeping the suite short and reliable.
How to perform a smoke test: 6 steps
To perform a smoke test, identify the few functions the product cannot live without, turn them into short repeatable test cases, run them on every new build in a production-like environment, and accept or reject the build based on a single pass or fail result. The steps below work for web, mobile and API products.
- Identify the critical paths. List the flows that would make the product unusable if broken: start-up, sign-in, the main screen, the core transaction (checkout, booking, payment, upload) and any integration the business depends on.
- Write short, independent test cases. One test per critical check, each able to run on its own with known test data. Keep the steps few and the expected results unambiguous.
- Prepare the environment and data. Use a stable, production-like environment with seeded accounts and test payment methods. Smoke tests that depend on shared, changing data become flaky quickly.
- Run the suite on the new build. Trigger it automatically from the pipeline, or run the checklist by hand for very early products.
- Make a go or no-go decision. Any failure rejects the build. Do not “pass with exceptions”; if a check is not critical, it does not belong in the smoke suite.
- Report and fix. Send the failure, logs and screenshots to the developers who made the change, fix the build and run the smoke again before any other testing.
What goes into a smoke test suite? A sample checklist
A good smoke test suite contains only the checks whose failure would make further testing pointless, typically between 5 and 30 test cases that run in a few minutes. The exact list depends on the product, but most suites cover start-up, authentication, navigation, the core transaction and key integrations.
Smoke test example: an e-commerce web application
The table below shows a realistic smoke test checklist for an online store. Each line is a single check with a clear pass condition.
| # | Check | Pass condition |
|---|---|---|
| 1 | Home page loads | HTTP 200, main navigation and product grid visible |
| 2 | User can sign in | Test account logs in and sees its account name |
| 3 | Search returns results | A known product appears for a known query |
| 4 | Product page opens | Price, images and “Add to cart” button render |
| 5 | Cart works | Item is added and cart total updates |
| 6 | Checkout completes | Test card payment succeeds in sandbox, order number shown |
| 7 | Order confirmation is sent | Confirmation event or email reaches the test inbox |
| 8 | Health endpoint is green | API, database and payment provider report healthy |
Notice what is missing: discount edge cases, address validation rules, every payment method, browser compatibility. Those belong in functional and regression suites. The smoke test only proves the store can take an order.
Smoke test examples for mobile apps and APIs
For a mobile app, a smoke suite typically checks that the app installs and launches without a crash, the onboarding or login screen appears, a user can sign in, the home screen loads data from the backend and push notification registration succeeds. For an API, it checks that the service starts, the health endpoint responds, authentication returns a token, and one read and one write call on the main resource succeed with the expected status codes and response shape.
Types of smoke testing: manual, automated and hybrid
Smoke testing can be manual, automated or a mix of both. Automated smoke tests are the standard choice for any product with a CI/CD pipeline, while manual smoke checks still make sense for very early products and for visual or device-specific checks that are hard to automate.
| Type | How it works | Best for | Main drawback |
|---|---|---|---|
| Manual | A tester follows a short written checklist on each build | Prototypes, MVPs, infrequent releases | Slow, inconsistent, does not scale to many builds a day |
| Automated | Scripts run the checks from the CI/CD pipeline on every build | Products with frequent merges and deployments | Needs upfront effort and ongoing maintenance |
| Hybrid | Automated core checks plus a few manual looks at visuals or devices | Mobile apps, UI-heavy products | The manual part can quietly be skipped under deadline pressure |
Smoke testing at different test levels
Smoke tests are not limited to the full system. Teams often run a smoke check at several levels: an integration smoke confirms that services start and can talk to each other, a system smoke confirms that end-to-end critical flows work in a deployed environment, and an acceptance smoke confirms a release candidate is ready for business users. Unit tests already run on every change, so they are rarely called smoke tests, although a failing unit stage blocks the pipeline in the same way. For how unit tests fit into the picture, see our explainer on unit testing in software development.
Smoke testing vs sanity testing vs regression testing
Smoke testing checks that a new build is stable enough to test at all, sanity testing checks that a specific fix or small change works as intended, and regression testing checks that existing features still work after any change. They run in that order of depth: smoke is the widest and shallowest, regression the deepest and slowest.
| Aspect | Smoke testing | Sanity testing | Regression testing |
|---|---|---|---|
| Question it answers | Is this build testable? | Does this fix or change work? | Did anything else break? |
| Scope | Broad and shallow, all critical paths | Narrow and focused on the changed area | Broad and deep, the whole product |
| When | On every new build and deployment | After a bug fix or minor change | Before releases and after significant changes |
| Typical duration | Minutes | Minutes to an hour | Hours, sometimes days if manual |
| Scripted? | Yes, a fixed and stable suite | Often unscripted or ad hoc | Yes, a large maintained suite |
| Usually automated? | Almost always | Sometimes | Mostly, with some manual checks |
| Result if it fails | Build rejected, no further testing | Fix sent back to the developer | Release blocked until defects are fixed |
A simple way to remember the difference: smoke asks “does it run?”, sanity asks “does the thing we just changed make sense?” and regression asks “does everything that used to work still work?” For the wider map of test types and how QA teams combine them, see our guide to quality assurance in software development.
How does smoke testing work in a CI/CD pipeline?
In a CI/CD pipeline, the smoke suite runs automatically right after the build and unit test stages, and again right after each deployment; if it fails, the pipeline stops and the build is not promoted. This turns smoke testing from a manual habit into an enforced quality gate.
A typical sequence looks like this: build, unit tests, deploy to a test environment, smoke tests, then the longer functional and regression suites, then deploy to production, then a post-deployment smoke test against production. The two smoke stages catch different problems. The pre-release smoke catches broken code; the post-deployment smoke catches broken configuration, secrets, migrations and infrastructure.
Here is a simplified GitHub Actions job that runs a Playwright smoke suite against a freshly deployed staging environment and fails the pipeline if any smoke test fails:
smoke-test:
needs: deploy-staging
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- run: npm ci
- run: npx playwright install --with-deps chromium
- name: Run smoke suite against staging
run: npx playwright test --grep @smoke
env:
BASE_URL: https://staging.example.com
Two details make this work in practice. The @smoke tag lets the team keep smoke tests inside the main test project but run only the tagged subset, and the timeout-minutes limit prevents a hanging environment from blocking the pipeline for an hour. The same idea applies in GitLab CI, Jenkins, Azure DevOps or any other runner. For the full pipeline design, see our guide to CI/CD in software development.
How long should a smoke test suite take?
A smoke test suite should usually finish in under 5 to 10 minutes, and many teams aim for under 5. If it takes longer, it is no longer giving fast feedback, and developers start ignoring or bypassing it. When a suite grows past that limit, move the slower or less critical checks into the regression suite instead of accepting a slower gate.
Smoke testing tools in 2026
Most teams build smoke tests with the same automation tools they already use for functional testing, then tag a small subset as the smoke suite. The right tool depends on what you are testing: a browser UI, a mobile app or an API.
| Layer | Common tools | Typical smoke checks |
|---|---|---|
| Web UI | Playwright, Cypress, Selenium WebDriver | Page loads, login, core user flow |
| Mobile | Appium, Espresso (Android), XCUITest (iOS), Maestro | Install, launch without crash, sign-in, home screen data |
| API | Postman with Newman, REST Assured, pytest with requests, k6 | Health endpoint, auth token, one read and one write call |
| Test runners | JUnit, TestNG, pytest, Jest, Vitest | Grouping and tagging the smoke subset |
| CI/CD | GitHub Actions, GitLab CI, Jenkins, Azure DevOps | Running the suite as a gate after build and deploy |
| Production checks | Synthetic monitoring in your observability platform | Scheduled smoke-style checks of live critical paths |
Tool choice matters less than discipline. A ten-test Playwright suite that runs on every merge is worth more than a sophisticated framework nobody maintains.
Advantages and limitations of smoke testing
The main advantage of smoke testing is that it catches build-breaking defects within minutes at very low cost; the main limitation is that it says almost nothing about the quality of anything outside the critical paths. A passed smoke test means “worth testing”, not “ready to release”.
| Advantages | Limitations |
|---|---|
| Finds critical failures within minutes of a build | Shallow by design, misses most functional defects |
| Saves QA time by rejecting untestable builds | Can create false confidence if treated as a release check |
| Easy to automate and run on every change | Needs maintenance as critical flows change |
| Catches environment and configuration errors after deployment | Flaky tests quickly erode trust in the gate |
| Gives a simple, shared go or no-go signal | Grows slow if teams keep adding non-critical checks |
Smoke testing best practices
The best smoke suites are short, stable, automated and strictly limited to critical paths; most failures of smoke testing come from suites that grew too big or too flaky to trust. These seven practices keep a suite useful:
- Keep it small. Start with 5 to 15 checks and add a new one only if its failure would make further testing pointless.
- Set a time budget. Agree on a maximum runtime, such as 5 minutes, and treat going over it as a defect.
- Make every test independent. Each check should create or reset its own data and run in any order.
- Fix or remove flaky tests immediately. A gate that fails randomly teaches people to re-run and ignore it.
- Run it in a production-like environment. Same configuration style, same integrations in sandbox mode, realistic data.
- Smoke-test production after every release. Use read-only or dedicated test accounts so live checks never touch real customer data.
- Review the suite every quarter. Remove checks for retired features and add checks for new critical flows.
Metrics to track for your smoke suite
Track a few simple numbers to know whether the smoke suite is doing its job: the smoke pass rate on the main branch, the median suite runtime, the flaky failure rate (failures that pass on re-run) and the number of defects found in later stages that a smoke test should have caught. These sit naturally alongside delivery metrics such as change failure rate, which our guide to software development KPIs explains.
Common smoke testing mistakes
The most common smoke testing mistake is letting the suite turn into a mini regression suite that takes too long and fails too often. Other frequent problems are easy to spot once you know them:
- Testing edge cases in the smoke suite instead of the critical happy paths.
- Running smoke only before releases rather than on every build, which delays feedback by days.
- Skipping the post-deployment smoke, so configuration errors reach users first.
- Sharing test data between tests, which causes random failures when tests run in parallel.
- Allowing manual overrides of a failed smoke “just this once”, which defeats the gate.
If your releases still break on day one despite a smoke suite, an independent QA assessment can review which critical paths are actually covered, measure flaky rates and runtimes, and rebuild the gate so the team trusts it again.
Frequently asked questions
What is smoke testing in software development?
Smoke testing in software development is a quick set of checks run on every new build to confirm that its most critical functions work, such as launching, signing in and completing the core transaction. It decides whether the build is stable enough for deeper testing. A failed smoke test rejects the build immediately, so testers do not waste time on software that is fundamentally broken.
What is a smoke test in software development, with an example?
A smoke test is a short automated or manual check of a build’s critical paths. For an online store, a smoke test might confirm that the home page loads, a test user can sign in, a product can be added to the cart and a sandbox payment completes with an order number. If any of these checks fails, the build goes back to the developers before any other testing starts.
What is the difference between smoke testing and sanity testing?
Smoke testing is a broad, shallow check that a whole new build is stable enough to test. Sanity testing is a narrow check that a specific bug fix or small change works as intended. Smoke testing runs on every build and is almost always automated, while sanity testing runs after targeted changes and is often done by hand. Some glossaries, including ISTQB, treat the two terms as synonyms.
Is smoke testing the same as regression testing?
No. Smoke testing checks only the critical paths of a new build in a few minutes to decide whether it is testable. Regression testing re-runs a much larger suite to confirm that existing features still work after a change, and it can take hours. Smoke testing runs first as a gate; regression testing runs later, before a release.
How many tests should a smoke test suite have?
Most smoke suites contain between 5 and 30 tests, and the right number is the smallest set that covers every critical path of the product. A useful rule is to include a check only if its failure would make all further testing pointless. If the suite takes longer than about 5 to 10 minutes, it has probably grown too large.
Can smoke tests be automated?
Yes, and for any product with a CI/CD pipeline they should be. Automated smoke tests run on every build and deployment using tools such as Playwright, Cypress, Appium or Postman with Newman, and they block the pipeline when a critical check fails. Manual smoke checklists still make sense for early prototypes and for visual checks that are hard to automate.
Who is responsible for smoke testing?
QA or test automation engineers usually design and maintain the smoke suite, DevOps engineers wire it into the CI/CD pipeline, and developers fix any build that fails it. In small teams without dedicated testers, developers own the whole process. Whoever owns it, one person should be clearly accountable for keeping the suite fast and reliable.
Sources
- ISTQB, Glossary of Terms used in Software Testing, entries “smoke test” and “build verification test” (v4.2, 2023)
- Steve McConnell, Daily Build and Smoke Test, IEEE Software, vol. 13, no. 4, July 1996, pp. 143–144
- NIST, Planning Report 02-3: The Economic Impacts of Inadequate Infrastructure for Software Testing (2002)
- Playwright documentation, Test annotations and tags