Skip to content

Web app monitoring

Your health check is green. Is the app actually usable?

A green health check means the server is up — not that the app loaded for a real user. Sitewatch verifies everything your app needs is really being served — bundles, styling, auth and third-party scripts, the endpoints it calls — on a schedule and the moment you deploy. A health check confirms the server is alive; this confirms the app arrived.

  • A deploy hook fires a full check the instant you ship
  • Every bundle, stylesheet, image and third-party script verified
  • Checks from EU and US, so an edge failure does not hide in the average
Deploy hooks: on every plan1 site: free forever

01What can go wrong

The server is fine. The app never arrived.

A modern app is layers — a shell, a bundle, styling, third-party scripts, the endpoints it calls. A health check looks at exactly one of them.

  1. 01A deploy changes a bundle filename and the served page still asks for the old one.
  2. 02The first paint looks completely normal, so screenshots and status checks pass.
  3. 03But nothing interactive works — no forms, no buttons, no modals.
  4. 04Your health endpoint keeps answering, because the server genuinely is healthy.
  5. The app is a static picture of itself, for everyone.

02Why traditional monitoring misses this

A health endpoint reports on the server. Not on the app.

Uptime and health checks answer one narrow question, and it is not the one your users care about. We don't just check that your app is online — we check that everything it needs actually arrives.

Health check / uptime monitor

Call /health
It answers
Healthy

Never loads a real page or anything that page depends on.

Sitewatch

Opens each app page
Bundles are served
Styling is served
Third-party scripts load
Endpoints answer
Healthy

Only "healthy" once everything the app needs is really there.

03How Sitewatch catches it

One question, after every deploy.

Not "is the server up?" — but the one your users answer for you otherwise: did everything this app needs actually get served?

  • Entry pages resolve
  • App bundles are served
  • Styling is served
  • Fonts and images load
  • Auth scripts load
  • Third-party scripts load
  • Monitored endpoints answer
  • Content matches its baseline

04Typical failures we catch

The failures a health check will never see.

The page asks for a bundle that is gone

A deploy changes the filename and the cache still serves the old page.

Nothing interactive works, for every single user

The auth provider's script is not loading

A third-party script stops being served from their side.

"Sign in" does nothing and nobody can get in

An endpoint stopped answering

A backend change takes a route down or changes what it returns.

The app loads and then fails as soon as it needs data

The compiled styling does not match the markup

A deploy ships markup referencing styles that were never compiled.

Broken layouts, invisible text, unusable components

One region is serving a stale build

An edge location holds an old or corrupted file.

Half your users have a broken app and your dashboard looks fine

A page quietly stopped rendering its content

A route now returns a shell, an error page or something that is not a page at all.

Users and crawlers both hit an empty screen

05Fits your existing workflow

From deploy to verified

  1. 01

    Ship your deploy

    Merge to main, push to production, or cut a release. Your pipeline sends a deploy hook to Sitewatch.

  2. 02

    Everything gets verified

    Sitewatch opens your app's pages, reads what each one references, and fetches every bundle, stylesheet, image and third-party script it finds.

  3. 03

    Broken? You know in minutes

    A failing file becomes a Slack or email alert naming the exact resource and what a user would experience — with guidance tailored to the framework we detected.

06What happens the moment we find it

Detection is not the outcome. Rolling back is.

Every incident names the page and the file, so the revert decision takes seconds instead of a bisect.

We confirm it is real first

Every issue is re-checked before anyone is alerted, so a single slow response mid-deploy never pages the on-call engineer.

Explained in plain English

The alert describes what a user would hit, not only which request failed — useful to the whole team, not just whoever is deepest in the code.

Sent where your team already works

Slack, email, webhook, PagerDuty, Opsgenie or SMS, routed per site.

You can verify the rollback

Revert, run a check on demand, and close the incident on evidence rather than on the deploy log going green again.

07The app stack

Six layers. A health check only sees the first.

Pick a layer to see how it fails and what Sitewatch notices when it does — including where the honest limits are.

The server

Infrastructure

How it fails — The process crashes, the instance is overloaded, or the route times out.

How Sitewatch detects it — Availability checks catch outages, timeouts and server errors, and confirm them with a retry before alerting.

The document

Shell

How it fails — The route returns an error page, an empty shell, or something that is not a page.

How Sitewatch detects it — Each page is opened and compared against its baseline, so a collapse in content is visible even when the response looks fine.

The bundle

Application

How it fails — The page asks for a build artefact that is no longer being served — usually a filename that changed.

How Sitewatch detects it — Every file the page references is fetched. A missing bundle is named in the alert. This is the single most common cause of a dead app.

Styling

Presentation

How it fails — Compiled styling is missing or does not match the markup that shipped with it.

How Sitewatch detects it — Stylesheets and fonts are fetched and verified alongside scripts on every check.

Third-party scripts

Dependencies

How it fails — An auth provider, analytics or chat script stops being served from someone else's infrastructure.

How Sitewatch detects it — Third-party files the page loads are checked too — their outage becomes your incident, which is exactly when you want to know.

The endpoints

Data

How it fails — A route the app depends on stops answering, or starts answering with something the app cannot use.

How Sitewatch detects it — Monitored endpoints are called on the same schedule as the pages, checking the response and its content — not just that something replied.

09vs. what you already run

Health checks and error tracking vs Sitewatch

What it looks at

Health check:
One endpoint on the server
Sitewatch:
The pages users load, and everything they need

Missing bundle after a deploy

Health check:
Not detected
Sitewatch:
Detected, with the file named

Third-party script failure

Health check:
Not detected
Sitewatch:
Checked on every run

A page that stopped rendering

Health check:
Not detected
Sitewatch:
Content compared against its baseline

Regional edge failure

Health check:
Invisible from one location
Sitewatch:
Checked from EU and US on Pro

When you find out

Health check:
When a user reports it
Sitewatch:
Minutes after the deploy

5 min

Fastest check interval

2

Check regions on Pro (EU + US)

6

Alert channels

Know your app works — not just that the server answers

Connect a deploy hook and verify your next ship in under two minutes. Free plan, no credit card.

10Questions

Web app monitoring questions, answered