How to verify your site after every deploy (before customers tell you)
A deploy can succeed and still break the site. A short post-deploy checklist, a smoke-test script and the monitor settings that catch what a green pipeline misses.
· 7 min read · By the Spot Downtime team
A green deploy pipeline means the build finished and the files were copied. It does not mean the site works. A missing environment variable, a migration that did not run, a CDN serving stale files, or a route that now throws an exception all pass through a successful deploy and show up as complaints an hour later.
The fix is cheap: verify the things users depend on right after every release, automatically, and keep an external monitor running to catch whatever the script does not.
What deploys typically break
- Configuration. A secret that exists in staging but not production, or a changed variable name. The app starts, but every request that touches the missing value fails.
- Database. A migration that failed halfway, or code that expects a column that is not there yet.
- Caching. A CDN holding old HTML that references JavaScript files that no longer exist, giving a blank page.
- Routing and redirects. A rewritten rule that sends a page into a redirect loop, or a changed path that now returns 404.
- Partial rollouts. Some servers or containers run the new version, others the old. Failures look random.
- Third parties. A changed API key or callback URL that breaks payments, login or email.
Build a small smoke test
A smoke test is a handful of fast requests against production that prove the critical paths work. It is not a replacement for your test suite. Aim for under a minute and a few checks that matter most:
- The home page loads and contains something only the real page has.
- A health endpoint reports that the app can reach its database and key dependencies.
- An important API route returns the expected status and JSON shape.
- The login page renders. Optionally, a test account can sign in.
- Static assets referenced by the page load, and the certificate is valid.
A plain shell script is enough to start:
#!/usr/bin/env bash
set -euo pipefail
BASE="https://example.com"
check() { # url, expected status, expected text
local body status
body=$(mktemp)
status=$(curl -s -o "$body" -w "%{http_code}" --max-time 10 "$1")
if [ "$status" != "$2" ]; then
echo "FAIL $1: got $status, expected $2"; exit 1
fi
if [ -n "${3:-}" ] && ! grep -q "$3" "$body"; then
echo "FAIL $1: text '$3' not found"; exit 1
fi
echo "ok $1"
}
check "$BASE/" 200 "Sign in"
check "$BASE/healthz" 200 '"status":"ok"'
check "$BASE/api/v1/ping" 200 '"version"'Run it as the last step of the pipeline. If it fails, the pipeline fails and, better, triggers a rollback. Retry the script once or twice with a short pause first, because a freshly started instance may need a few seconds to warm up.
Test the thing, not the server
Give the app a real health endpoint
A health endpoint that always answers ok is useless. A good one checks the dependencies the app cannot work without, and stays fast:
GET /healthz
{
"status": "ok",
"version": "2026.11.04-1",
"checks": { "database": "ok", "cache": "ok" }
}Including a version field has a second benefit: your smoke test can confirm that the version now serving traffic is the one you just deployed, which catches stale caches and servers that missed the rollout. If there is a load balancer, run the check a few times, since each request may reach a different instance.
Deploy in a way that is easy to undo
- Keep the previous release available so a rollback is a single command, not a rebuild.
- Roll out to a small share of traffic first if your platform supports it, and compare errors before going to 100%.
- Make database migrations backward compatible, so old code keeps working against the new schema while you decide whether to roll back.
- Avoid deploying right before you leave. The first hour after a release is when most regressions appear.
Keep an external monitor running through the release
The script covers the moment of the deploy. Some failures only appear later: a memory leak in the new build, a cache entry that expires after an hour, a job that runs at night. A monitor that checks from outside every minute or few minutes covers that gap and also tells you when something breaks without a deploy at all.
- Add a keyword check. A website monitor in Spot Downtime can require specific text on the page. If the text disappears, the monitor counts as down even when the server still answers 200. See website monitoring.
- Add API assertions on the fields that matter, for example
statusequalsok. The API monitoring feature supports assertions on JSON fields, and the multi-step checks guide covers flows such as login then fetch. - Check slow responses too. A deploy that makes pages three times slower is a regression even if nothing returns an error. Track it as described in tracking API response times.
- Plan for the planned part. If a deploy needs a restart, schedule maintenance so the expected blip does not page anyone. With the Claude connector you can ask for a maintenance window around the deploy. Serving the pause properly is covered in 503 maintenance mode and Retry-After.
Because a failed check is confirmed from other regions before it alerts, a brief hiccup while instances restart is less likely to wake someone than a single failed request would. If you do see noise around releases, read how to reduce false uptime alerts.
A short post-deploy routine
- Pipeline runs the smoke test and fails or rolls back automatically on error.
- You open the site and click through one key flow yourself. Two minutes.
- Check the error tracker and logs for new exception types in the first 15 minutes.
- Confirm the external monitors are green and response times look normal.
- Note the release time. When an alert fires later, you can see at once whether it followed a deploy.
That last point pays off during incidents. When you have a timestamped record of what changed, a response to a site that has gone down starts with “what shipped?”, which is the most common cause of an outage.
Bulk HTTP status checkerCheck the status of your key URLs in one go after a release.Get new guides by email
Practical posts on monitoring, outages, error fixes and on-call, when they're published. No spam.
Keep reading
- Monitoring · How-toFree website monitoring: a complete setup that costs $0Uptime, SSL, DNS, speed, broken links, changes and a status page: how to monitor a website properly for free, which free tools to use for each, and what you give up.November 3, 2026 · 3 min read
- Monitoring · How-toWebsite change monitoring: tools, free options and catching defacementHow website change monitoring works, the free and paid tools for tracking page changes, and how to get alerted when your own site is defaced or injected with code.November 3, 2026 · 4 min read