Smoke Testing After Deployment: A Small Release Check

TL;DR: Smoke testing after deployment is a short check that the released app can still perform its essential jobs. Run it against the intended environment with a known account and a clear expected result. Decide who will investigate or roll back a failed release before you need that decision.

Your deployment says “complete.” You open the dashboard in your usual browser and everything looks fine. A customer signs in from a fresh session and lands on an error page.

The deployment finished, but your quick look never checked the path that customer took. A post-deployment smoke test gives you a repeatable way to ask whether the released version works well enough to keep serving users.

You do not need a long checklist for this. You need a small check with an identifiable release, a meaningful result, and someone responsible when it fails.

What should a post-deployment smoke test prove?

A smoke test answers a narrow question: can this version perform the basic jobs your users depend on? It might check that a visitor can reach the app, sign in, open their workspace, and save one harmless record.

The GOV.UK deployment guide recommends a simple, fast check after deployment that exercises essential dependencies. Its database example is useful: follow a path that would fail if the database were unavailable. A page loading by itself would miss that problem.

For a small project-management app, opening the landing page is one check. Creating a task, reloading, and finding that task in the correct workspace is another. The second path gives you evidence about sign-in, account access, and a write that your app can read back.

That still leaves plenty uncovered. A successful task creation tells you little about invitations, exports, or changing a subscription. Choose a few essential paths for the release check; keep the wider suite in your regression testing process.

How do you keep the check small and tied to the release?

Start with the change you are releasing and the failure you most need to catch. If you changed sign-in, include a fresh sign-in. If you changed task storage, include creating and reopening a task. Keep a stable core check, then add a targeted check when a release touches another critical area.

Write down the context alongside the result:

  • Environment: the production app URL, including the workspace path.
  • Release: the build identifier from your deployment system.
  • Account: a dedicated release-check account with the intended role.
  • Starting data: an empty test project inside a dedicated workspace.
  • Expected result: a newly created task remains visible after reload.
  • Response owner: the person who can investigate and decide on recovery.

Use the release identifier your deployment system actually provides. If you are checking a staging URL, label the result as staging. If your app displays a version, compare it with the expected release. If it does not, use the deployment record to connect the check to the version under review; a timestamp alone cannot establish which code served the page.

Keep test records easy to recognize and clean up. A task named smoke-2026-10-09-01 is easier to distinguish from yesterday’s successful check than another task called “Test.” Use a fresh suffix for every run so an old record cannot satisfy the expectation.

Avoid turning this into every test your app could need. A release check that takes too long to interpret loses its value as a quick decision. Set a practical deadline and make a slow or unfinished check visible as unresolved.

What starting state makes the result trustworthy?

Decide whether you are checking sign-in or a journey that starts after sign-in. These are different starting states. Reusing an authenticated browser session can be useful for testing task creation, but it skips the login path you may have just changed.

For the fresh-session check, begin signed out. Use a dedicated account with the same role as the user you want to represent. An administrator successfully opening a page does not establish that a regular member can reach it.

For a write check, describe the result precisely. Here is a starting instruction you could adapt:

Open the deployed app and sign in with the release-check account. Confirm that you are in the Release Checks workspace. Create a task with this run’s unique name. Reload the page and confirm that the same task appears in that workspace. Report any error or point where you could not continue.

Supply the actual URL and unique name for the run. Define cleanup separately so a failed cleanup does not erase the evidence you need to investigate.

Browser state also needs care. Playwright’s authentication documentation warns that saved state can contain cookies and headers capable of impersonating an account. If your engineer uses saved browser sessions, treat those files as credentials and keep them out of the repository.

Some journeys require an email link or a human verification step. Arrange that starting state before relying on the check. If a run cannot get the required credential approval or verification, you have an incomplete check; you have not established that the release broke the app.

How does WayRunner check progress in the browser?

You can give WayRunner a deployed URL and a plain-English goal such as the task-creation check above. Its Planner chooses an action, the Executor performs it, and a fresh observation gives the Planner evidence for the next step.

One detail matters when a release leaves a button looking normal but doing nothing. WayRunner compares page-state signals before and after eligible actions, including ordinary clicks. When the action reports success but the recorded state is unchanged, it can classify that action as no_effect.

The Executor’s state signal includes the URL, a page summary, and non-password input values. Password fields contribute a length-only signal rather than their value. For observations without that Executor signal, the comparison falls back to the URL and page summary.

This helps distinguish issuing a click from observing progress. It is still one piece of evidence. A click that changes the page does not establish that the task was saved, and an unchanged page does not by itself diagnose a broken release. The instruction still needs the final check after reload.

WayRunner also records explicit assertions with the expectation, whether it held, and the observed result. Make the expected workspace and unique task name part of the goal so the result has something specific to assess.

The boundary is the rendered app. A visible task after reload is useful evidence, but it does not inspect your database, prove every permission boundary, or certify the whole release. If you need those checks too, the end-to-end testing tools guide explains how browser and server evidence can fit together.

What should happen when the check fails?

Decide the response before deployment. Otherwise a red result starts a debate about who owns it while users are already encountering the problem.

Use the failed step and its evidence to choose the next action:

  • A critical journey fails on the intended release: investigate immediately and use the agreed recovery decision.
  • The wrong URL, account, or fixture was supplied: correct the starting state and rerun; retain the invalid result as context.
  • Credentials or human verification block progress: complete the required step and obtain a finished check.
  • The journey passes but another important area is untested: record that gap and run the relevant additional check.

Do not rerun until you get a green result and discard the first failure. If a second run passes without an understood change, the first failure remains evidence of something intermittent. Record both outcomes and investigate the difference.

Rollback also needs judgment. A previous app version may not work with a new database change, so ask the person responsible for the release whether rollback is a usable recovery option. A browser test result is an input to that decision; WayRunner does not make or execute the deployment decision for you.

If you are choosing how to own the broader set of checks, the regression testing tools comparison covers maintenance and release responsibilities. For this smoke test, keep the response small and explicit: who reviews the evidence, who decides, and what they can do next.

A useful release check connects one deployed version to a few essential outcomes. Keep its starting state controlled, save the evidence, and treat an unfinished check as unresolved. That gives you a clearer release decision than opening your own dashboard and hoping it represents every user’s experience.

Try WayRunner with one critical journey on your deployed app.