A customer signs in and books the last appointment on a calendar. The screen says the booking succeeded. After a refresh, the slot is still available. A release team that checks only whether the website loads could miss a fault that lets two people book the same appointment.
Smoke testing is a short set of checks that shows whether a software build works well enough for deeper testing. A build is a specific version of the application. The checks follow a few essential tasks far enough to confirm their outcomes. In the booking example, that means finding the saved appointment and seeing that the slot is no longer available.
What decision does a smoke test support?
A smoke test supports one decision: whether a build works well enough for further testing to produce useful results. If nobody can sign in to a booking application, spending an afternoon checking calendar layouts is a poor use of time. A failed sign-in check gives the lead a reason to pause that work and direct an engineer to the fault.
A pass has a narrower meaning than release approval. One successful booking says nothing about whether a hundred customers can compete for the same slot. It also leaves open whether a user can view another customer’s details. Those questions deserve their own tests. A useful result names the build and the paths checked so that the next person understands what passed.
Where the check belongs
A team can run the short suite when a new build reaches a shared test environment. That timing catches problems introduced when separate components first run together. A calendar feature might work on a developer’s laptop and still fail in staging because the application lacks permission to write to the shared database. The same script can expose both outcomes if it checks the saved record.
Before setting a frequency, the release lead should identify the decision that each run will inform. A run before a long test cycle protects the time of the testers. A run immediately after deployment answers a different question: did the installed version start correctly in this environment? The two suites can share checks without needing identical permissions or data.
Which user journeys belong in a smoke test?
A smoke test should start with the promise that brings someone to the product. A patient wants an appointment. A warehouse clerk needs to record goods received. A subscriber expects access to a paid article. Each promise has a point where the business can tell whether the work actually happened. That point makes a better target than a list of popular screens.
How a team keeps the list short
For every proposed check, the team can ask what work would stop if it failed. A missing logo might need attention before launch. A missing appointment record makes further booking tests difficult to interpret. Only the second fault needs to block the next round by default. Writing down that distinction prevents a short suite from becoming a second full test plan.
What does a useful test case look like?
A good case names a starting condition, an action and an observable result. “Test booking” leaves too much to the tester. “Book the reserved test slot and reopen the appointment by its reference” tells another person what to do and where to look. It also gives an engineer a practical starting point if the check fails.
A worked example from a booking application
Suppose a test clinic has one available slot at ten on Tuesday. A tester uses a designated patient account to reserve it. The application returns a reference. In a fresh session the tester opens that reference and confirms the clinic and time. A second designated account then checks the calendar. The original slot should no longer be offered.
Two observations matter here. The first checks that the booking survived the original session. The second checks that availability changed for someone else. If the reference opens but the slot remains available, the report can name the broken step. The engineer can investigate availability updates instead of starting from a vague report that the calendar is broken.
A smoke testing checklist for the release record
- Identify the build and environment so another person can locate the same release.
- Reserve a test account and a slot that no other run will use.
- Define the expected change in the saved record before running the check.
- Capture the actual result and the reference needed to investigate a mismatch.
- Release the slot afterwards and confirm that the next run can start cleanly.
A manual run can follow the same list as an automated one. For a product with frequent interface changes, a person may be able to follow a revised booking flow before an automated script is updated. The result still needs to meet the same standard. Recognising the confirmation screen is only the beginning of the check.
How does smoke testing differ from regression testing?
Smoke testing checks whether essential paths work in a new build. Regression testing looks for unintended changes in behaviour that previously worked. The distinction is scope and purpose. The same booking check can serve both purposes. A regression suite might also cover cancellations across time zones or refunds after a clinic changes its schedule.
Deliverydevs sets up CI/CD pipelines, so checks like these can run on every build before release.
How can smoke tests run automatically?
The best candidates for automation have predictable inputs and a result the software can inspect. A test that reserves a different slot on every run can work if the script creates the slot and records its identifier. A test that selects whatever appointment happens to be first on a shared calendar leaves too much to chance.
Choose the cheapest check that answers the question
A browser check is useful when the risk lies in the path from the screen to the saved booking. If the question is simply whether the booking service accepts a valid reservation, a request sent directly to the service can answer it without opening a browser. Both checks have value. They cover different ways the product can fail.
A team introducing automated smoke testing should run its first script alongside the existing release process. That gives the engineers a chance to discover which failures come from the product and which come from the setup. Once the result is dependable, a failing check can stop the next stage automatically. Someone should own that decision and know how to investigate it.
Put the result where the release decision happens
In continuous integration (CI), a shared pipeline can identify the build that produced each result. To check a deployed application, the pipeline must first confirm that the intended version is running. Otherwise a successful test against yesterday’s version could appear to clear today’s change. Recording the deployed version alongside the test output makes that mistake easier to spot. Smoke checks are often the first gate in a continuous testing setup.
Deliverydevs describes pipeline automation as part of its DevOps services. For a team considering that work, a useful design question is what the pipeline should do when a required check cannot run. Recording the result as blocked preserves an important distinction: the release has no evidence for that path yet.
What should happen when a smoke test fails?
When a smoke test fails, the team should first preserve the evidence from the original attempt. Record the step that failed and what the tester observed. A timestamp and a booking reference can help an engineer locate the corresponding activity. Repeating the check immediately with the same account might create another reservation or obscure the state that caused the first failure.
Separate a product fault from a blocked check
An expired test password can stop a run before it reaches the booking screen. That does not establish that customers cannot book. The tester should record where the run stopped and repeat it after the account is restored. By contrast, a fresh booking reference that opens the wrong appointment is evidence of a product fault that deserves investigation before testing proceeds.
A repeat failure on only one browser deserves the same care. The release lead can compare the affected browser with the list the product supports. If customers depend on it, a pass elsewhere does not resolve the fault. The release record should state which users would be affected and who decides whether testing can continue on the unaffected paths. That decision lets other work proceed where appropriate while keeping the original failure visible until a corrected build passes the same check.
How does the approach change for business software?
In a business application, a successful action often has a consequence in another team’s records. An entry clerk may see a receipt immediately while a stock controller sees no change. A check designed around the clerk’s confirmation alone will miss that gap. The team needs to decide which record is authoritative and when the change should appear. A screenshot alone cannot establish that.
The Orion Group case study describes Deliverydevs bringing operations across multiple companies into ERPNext. That project illustrates why company boundaries matter when records move through a shared system. A team testing a similar implementation could post one purchase invoice for Company A and confirm that it appears only in Company A’s ledger.
Set a clear limit on waiting
Some updates run in the background. An immediate lookup can fail even though the application is working as designed. Waiting indefinitely creates the opposite problem. If the product specifies a window for the update, the test can check within that window and report how long it waited. Without an agreed expectation, a slow result is difficult to classify consistently.
FAQs
Should smoke tests run in production?
Smoke tests belong in production only when their side effects are acceptable. Looking up a designated test record may be enough to verify a deployment. Making a real appointment could occupy a slot that a patient needs or send a reminder to the wrong person. A team that needs a live transaction should design the test data and cleanup before enabling it.
When should a team retire a check?
A check can retire when its underlying risk disappears or another check covers the same outcome more reliably. If a clinic removes guest bookings, retaining a guest checkout script produces noise with every release. The owner should confirm that the feature has actually retired and keep the signed-in booking path covered.
Deliverydevs builds CI/CD pipelines that carry each change from build to deployment, so checks like these run before every release.