Uptime Monitor Says Up but Users See Errors: Why and Fix

Your uptime monitor is green but customers cannot sign up or pay. Learn why a 200 response hides real failures and add deep health checks, body assertions and one flow check.

An uptime monitor stays green while users see errors because it only checks that a URL answers with a 200. It does not check that the database works, that the JavaScript loads, or that sign-up and checkout complete. Fix it with three layers: a health endpoint that tests real dependencies and returns 503 when one fails, a monitor that asserts on the response body, and one scripted check of your most important user flow.

Most small teams set up a ping on the home page and feel safe. Then a deploy breaks the payment call, the home page still returns 200, and the first alert is an angry email. Many engineers have written about this gap, for example this post on uptime monitors that say green while users disagree and this one on health endpoints that lie. This guide shows how to close the gap without buying a large monitoring suite.

Step 1: Understand What a 200 Does and Does Not Prove

A 200 status means the web server or CDN answered. That is all. These failures all return 200:

  • The HTML shell loads but the JavaScript bundle is missing, so the app never mounts.
  • The page renders but the database is down, and the API returns an empty list.
  • A deploy renames a field, so every client reading the old name breaks.
  • A CDN serves a cached copy of the page while your origin is dead.
  • Background jobs stopped, so emails and exports silently stop.

Each one is a real outage for users and a green tick for a ping monitor. Write down which of these could happen to your product. That list becomes your check list.

Step 2: Build a Health Endpoint That Tests Real Dependencies

A route that returns { "ok": true } without touching anything only proves the process is alive. Make it check what your app needs to serve a user: the database, the cache, and any queue. Keep each check short with a timeout.

// Express example. The idea works in any framework.
app.get("/health", async (_req, res) => {
  res.set("Cache-Control", "no-store");

  const withTimeout = <T>(p: Promise<T>, ms = 2000) =>
    Promise.race([
      p,
      new Promise<never>((_, rej) => setTimeout(() => rej(new Error("timeout")), ms)),
    ]);

  const checks: Record<string, "ok" | "fail"> = {};
  try { await withTimeout(db.query("SELECT 1")); checks.db = "ok"; }
  catch { checks.db = "fail"; }
  try { await withTimeout(redis.ping()); checks.cache = "ok"; }
  catch { checks.cache = "fail"; }

  const healthy = Object.values(checks).every((v) => v === "ok");
  res.status(healthy ? 200 : 503).json({ status: healthy ? "ok" : "degraded", checks });
});

Three details matter. Return 503 when something fails, so any monitor sees it. Send Cache-Control: no-store, because a CDN that caches the endpoint can serve a stale "ok". And do not expose secrets or version numbers in the body, since this URL is public.

Do not put slow or expensive checks here, such as a call to a paid third-party API. Check those in Step 4.

Step 3: Make the Monitor Read the Body

Most uptime tools let you assert that the response contains some text, or match a JSON value. Turn this on. For the health endpoint, require the text "status":"ok". For your home page, require a string that only appears when the app really rendered, such as a heading from the page, not the <title> that exists in the empty HTML shell.

You can test the idea yourself with curl:

curl -s -o /dev/null -w "%{http_code}\n" https://yourapp.com/health
curl -s https://yourapp.com/health | grep -q '"status":"ok"' && echo PASS || echo FAIL

If your monitor cannot assert on the body, switch to one that can.

Step 4: Check One Full User Flow

The health endpoint covers your servers. It does not cover the path a customer walks. Pick the single flow that loses you money when it breaks: sign-up, login, or checkout. Run it on a schedule from outside your network.

A small Playwright script is enough:

import { chromium } from "playwright";

const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto("https://yourapp.com/login");
await page.fill("#email", process.env.CHECK_USER!);
await page.fill("#password", process.env.CHECK_PASS!);
await page.click("button[type=submit]");
await page.waitForSelector("text=Dashboard", { timeout: 15000 });
await browser.close();

Use a dedicated test account with no real data. Run it every 5 to 15 minutes from a scheduler and alert when it fails twice in a row. Browser checks cost more than pings, so run one or two, not twenty. Synthetic monitoring is the standard name for this.

Step 5: Watch the Things a Check Cannot See

Some failures happen only for some users: one browser, one country, one plan. A synthetic check will not catch them. Background jobs are another blind spot, because nothing visits a URL when they stop. For those, use a heartbeat that your job calls on success, as described in Cron Job Stopped Running Silently? How to Monitor Cron Jobs. Also watch the error rate of real traffic. If errors jump after a deploy while the monitor is green, real users are the signal.

Step 6: Alert Without Creating Noise

Every added check can add noise. Keep it manageable:

  • Require two failures in a row before paging anyone.
  • Send low-priority checks to email or chat, and only the flow check and the health endpoint to your phone.
  • Review every false alarm and fix the check, not the person.

For more on this, read Too Many Production Alerts? Fix the Noise. If you do not have a page for customers yet, Status Page for a Small SaaS explains what to show.

How Relia Helps

Relia has uptime monitors and checks of key pages, and it also watches your users, APIs and database. When a deploy, a failing request and users hitting an error line up, Relia groups them into one incident explained in plain words and shows who was affected. That covers the case where a ping is green but real traffic is failing. It also has a public status page. You can try the live demo first. There is a Free plan, and Growth is $19/month.

FAQ

Why does my uptime monitor say up when my site is down?

The monitor probably checks only the status code of one URL. A CDN, a cached page or an HTML shell can return 200 while the app behind it fails. Assert on the body and add a deep health endpoint.

What should a health check endpoint check?

The things a request needs: database, cache and queue, each with a short timeout. Return 503 if any fails, and mark the response as not cacheable. Keep it fast and free of secrets.

Is a 200 OK response enough for uptime monitoring?

No. It proves a server answered, not that the product works. Combine it with body checks and one scripted flow such as login or checkout.

How often should I run uptime checks?

Pings and health checks every 1 to 5 minutes are common. Browser flow checks every 5 to 15 minutes keep cost down. Alert after two consecutive failures to avoid false alarms.

All guides