HTTP 200, but the Checkout Is Gone: A Recorded Deploy Experiment
We deliberately broke a demo storefront after a successful deploy. Uptime stayed green; browser checks exposed two JavaScript errors and the missing order form.
The release was green. The order form was missing.
We deliberately broke a small storefront to answer a practical question: what would the monitoring show if a release removed the checkout form but left the page available?
GitHub Actions finished successfully. The storefront still returned HTTP 200. The coffee product, price and surrounding content were visible. The part a visitor needed to place an order was gone.
DeployWatchers reported two browser JavaScript errors and a visual difference of 25.35% in this recorded run. The uptime check continued to pass.
Watch the 60-second demonstration (opens in a new tab).
This was a controlled experiment on a fictional store, not an incident on a customer's website. There was no real payment integration, and no orders or personal details were submitted. The recording is edited for length; it is not a measurement of alert delivery time.
A small storefront with a predictable failure
The demo is a static HTML, CSS and JavaScript site. It has a product, a grind selector, a quantity control and a local-only order confirmation. A healthy release mounts the form from an HTML template.
The broken release simulates code written for an SDK that is no longer available:
if (release.scenario === 'broken') {
document.documentElement.classList.add('release-regression');
console.error(
'[demo] Checkout configuration is incompatible with the new SDK.'
);
const checkoutSdk = undefined;
checkoutSdk.mount('#checkout-slot');
}
// The exception above prevents this statement from running.
document.getElementById('checkout-slot').replaceChildren(
document.getElementById('order-template').content.cloneNode(true)
);
The undefined SDK is intentional. We are not claiming that a particular payment provider released a faulty SDK. The example makes the dependency between initialization and the missing form easy to reproduce.
The browser throws before reaching the form-mounting statement. Other markup already delivered in the document remains visible. The demo also applies a different background to the checkout panel, making the visual regression clear in a short recording. Both the missing form and the style change contribute to the screenshot difference.
Why HTTP 200 remains correct
The server successfully delivered the HTML document. The exception happened later, when the browser executed JavaScript.
HTTP 200 response semantics (opens in a new tab) describe the successful request. They do not establish that the client-side application initialized or that a visitor completed an order.
There is no contradiction between these observations:
| Signal | Result in the recorded demo | What it established |
|---|---|---|
| GitHub Actions deployment | Successful | The configured deployment steps completed |
| Uptime | Passed, HTTP 200 | The page was reachable and returned a successful response |
| Browser JavaScript check | Failed, two errors | A console error and an uncaught exception occurred while loading the page |
| Visual comparison | Failed, 25.35% changed | The captured page differed from the approved baseline |
The percentage belongs to this capture and its settings. It is not the percentage of customers affected, a measure of revenue lost, or a universal result for this failure.
What the JavaScript check found
The errors were related, but distinct:
CONSOLE ERROR
[demo] Checkout configuration is incompatible with the new SDK.
UNCAUGHT EXCEPTION
Cannot read properties of undefined (reading 'mount')
The first entry came from our explicit diagnostic message. The second was the browser reporting the failed method call. Two error entries did not mean two independent defects.
The useful information was the message and source location: execution stopped in checkout initialization before the form was mounted. That is more actionable than knowing only that a screenshot changed.
A page-load browser check can find errors reached during that visit. It will not necessarily find an exception that happens only after signing in, selecting a particular product or pressing a button. We did not need those interactions to expose this deliberately chosen bug.
What the visual check added
The visual comparison showed the user-visible consequence: the form was missing and the checkout panel looked different.
Console errors and screenshots answer different questions. An exception can occur without affecting the captured area. A CSS regression can make a page unusable without producing an exception. Here, both signals pointed to the same release.
For the comparison we first captured the healthy page and approved that screenshot as the reference. The broken release was compared against that baseline. We did not approve the broken screenshot to make the alert disappear.
Consistent capture conditions matter. Viewport, browser environment, fonts and dynamic content can change the rendered result. The Playwright visual comparison guide (opens in a new tab) explains why baselines and subsequent captures should use the same environment. The recorded percentage is a DeployWatchers result; it is not a claim that this demo runs Playwright Test's screenshot assertion unchanged.
Trigger checks after the public release is available
Our demo workflow uploads static files, atomically switches the active release, and checks its public health endpoint. Only after that does it report the deployment to DeployWatchers.
A matching integration step can look like this:
- name: Report deployment to DeployWatchers
env:
DEPLOYWATCHERS_TOKEN: ${{ secrets.DEPLOYWATCHERS_TOKEN }}
WEBSITE_ID: ${{ vars.DEPLOYWATCHERS_WEBSITE_ID }}
RELEASE_SHA: ${{ github.sha }}
run: |
curl --fail --silent --show-error \
--connect-timeout 10 --max-time 30 \
--request POST \
"https://deploywatchers.com/api/v1/websites/$WEBSITE_ID/deployments" \
--header "Authorization: Bearer $DEPLOYWATCHERS_TOKEN" \
--header "Accept: application/json" \
--data-urlencode "version=$RELEASE_SHA" \
--data-urlencode "commit=$RELEASE_SHA" \
--data-urlencode "environment=production"
This is an adaptation example. Set the website ID and create a deploy token scoped to that website, then store the token in GitHub secrets. Put this step after your own public release verification. Do not embed a token in the workflow file.
The hook returns HTTP 202 when it accepts the report and queues checks. It does not wait for those checks to pass. That is why our deployment job could finish green while the later browser results showed a regression. Making monitoring results a blocking release gate would require a separate waiting and decision mechanism; this example does not implement one.
Incident notifications also follow the configured confirmation thresholds. Do not infer a guaranteed notification time from the cuts in the video.
Keep the boundary between monitoring and checkout testing clear
This experiment demonstrated detection of a page-load exception and a visible regression. It did not demonstrate successful payment, stock reservation, order persistence or delivery of a confirmation email.
Those need application tests and, where appropriate, a controlled end-to-end scenario. A clean console and an unchanged screenshot can coexist with a failed API request after a click or an incorrect order total.
For a store, monitor the important public URLs separately, such as product pages, the cart and the checkout entry page. A check of the homepage does not automatically visit the rest of the site. Account-specific pages and transaction paths require their own authorized testing approach.
A useful post-deploy sequence
Start with a known-good release, enable the browser checks you need and review the visual baseline. After deployment, inspect availability, JavaScript results and screenshot changes together. If a regression is confirmed, fix or restore the release and verify recovery without replacing the healthy baseline with a broken one.
Our demo remained online throughout the failure. The extra signals made the difference between “the document was delivered” and “the page changed in a way that needs attention.”
DeployWatchers provides those post-deployment signals alongside availability monitoring. The recorded experiment shows what they caught, and the limits of what that evidence proves.
Catch problems after your next deployment
Monitor availability, browser JavaScript errors and visual changes with DeployWatchers.