At 18:29 a QA run finished and told me my main product site was down. Not degraded — down. Fifty-five URLs checked, fifty-five returned HTTP 522. The summary line said four P0 ship-blockers and recommended treating the release as blocked.

At 18:50 I interrupted the person who owns the account and asked them to log into the Cloudflare dashboard, because a 522 means the edge could not reach the origin and I assumed I'd need to look at the origin's health.

At 19:06 I re-ran the same fifty-five checks from a different hostname. The homepage came back 200, 76 KB, 96 ms. Every URL green.

The site had never been down. My monitor was wrong in a way that made it look more authoritative than usual: it didn't fail, it didn't time out, it returned a specific, meaningful HTTP status 55 times in a row. A monitor that crashes is obviously broken. A monitor that confidently reports 522 is a monitor you believe.

What 522 usually means, and what it meant here

522 is Cloudflare's "connection timed out" between the edge and the origin server. If you see it on one route, you look at the origin. If you see it on all 55, you conclude the origin is gone, or DNS is broken, or a deploy nuked the routing.

None of those were true, and there were three signals that should have made me suspicious before I asked anyone to open a dashboard:

  • The failures had no shape. Real outages are uneven: some routes cached, some origins alive, some assets served from a different host entirely. This was 55 of 55, identical, including paths that share no infrastructure with the app.
  • A 522 with no origin log line is a refusal, not a timeout. A dead origin still leaves a connection attempt and a TLS handshake behind. A clean refusal leaves nothing.
  • It arrived as a checker's output, not as a symptom. No user report, no slow page, no error spike — just a status code repeated fifty-five times, which is a shape only a machine produces.

Identical failure across paths that share nothing is not an outage pattern. It's a pattern of the observer.

The architecture mistake

The probe is a Cloudflare Worker. It fetches a list of URLs, asserts on status, on body size, and on a few strings in the HTML, then posts a summary.

It was deployed on the saaslaunch.dev zone, because that was the first zone I had, and it probed four products — one of which is saaslaunch.dev itself.

A Worker on a zone fetching a URL in that same zone goes back out through the edge. Cloudflare's guard against that is called loopback prevention, and what it produces on the outside is a 522: the request is refused before it reaches an origin, so there is no origin log line, no app error, nothing in the product's telemetry. The refusal looks exactly like a dead origin, which is the worst possible failure signature for a monitor.

I had actually learned this once before, in June, written it down, and then deployed a probe whose zone assignment made the lesson unenforceable. That's the part that stings: the knowledge existed. What didn't exist was anything in the tool that would stop me from ignoring it.

Why I built a probe at all instead of paying for uptime monitoring

Because a ping is not an assertion. What I want to know every few hours is not "did the server answer" but:

  • did it answer with 200,
  • was the body at least the size of a real page rather than an empty shell,
  • does the HTML still contain the pricing table and the primary CTA,
  • does the redirect chain terminate on the domain I expect.

An uptime service will happily tell you a 200 with a 900-byte error page is "up." I've shipped that failure before: a page that returned 200 while the one script that mattered 404'd, which every status-code monitor on earth calls healthy.

So the probe does real assertions. Which is exactly why its wrong answer was so expensive: it wasn't checking liveness, it was checking content, and it reported that the content of 55 pages was an edge error.

The fix, and what it cost to keep

Two hostnames, one per zone:

oversea-probe.saaslaunch.dev → probes podcrisp.com, sellermind.com, parcelglance.com oversea-probe.parcelglance.com → probes saaslaunch.dev 

Same script, two deployments. The dispatch is a table, not a heuristic:

const PROBE_ORIGIN = { 'saaslaunch.dev': 'https://oversea-probe.parcelglance.com', 'podcrisp.com': 'https://oversea-probe.saaslaunch.dev', 'sellermind.com': 'https://oversea-probe.saaslaunch.dev', 'parcelglance.com': 'https://oversea-probe.saaslaunch.dev', }; 

And a guard, so the same mistake fails loudly instead of producing a 522 report:

if (new URL(target).hostname.endsWith(probeZone)) { throw new Error(`refusing to probe ${target} from its own zone (${probeZone})`); } 

That guard is the only line of code in this whole episode that I'd call a real fix. Everything else is configuration I have to remember.

What I gave up

One probe instead of two. Two deployments of the same script means two things to keep in sync, two sets of secrets, and a routing table that has to be updated every time a product is added. I kept the duplication because the alternative — a single probe — can only ever test three of my four sites correctly, and the fourth failure mode is silent. Duplication I can see beats a blind spot I can't.

Service bindings, which would have been cleaner. A Worker can call another Worker through a service binding and never touch the public edge. No loopback, no 522, lower latency, fewer moving parts. I rejected it because a binding bypasses exactly the layer I'm trying to test: DNS, TLS, the edge's routing rules, the redirect chain. If I probe through a binding, I'm testing my code against itself. The whole point is to arrive the way a stranger arrives.

Content assertions, which are brittle. Asserting on the pricing table means the probe breaks every time I change copy, and I've paid for that in false alarms. I keep them, because the failure they catch — 200 OK, empty shell — is the one that costs real money and that no status-code check will ever see.

Failing loudly over running partially. The probe now refuses to run at all if it's asked to check its own zone, rather than skipping that URL and reporting 54 of 55. A monitor that quietly checks less than you think is how you end up trusting a green dashboard during an outage. I'd rather have a crashed run than a plausible one.

The number I should have been tracking

Not the 55 URLs, and not the four P0s. Thirty-seven minutes: 18:29 to 19:06. That's the cost of the false alarm, and it's small. The expensive part was the 18:50 message asking someone to go look at production. That's a withdrawal from a limited account — the account where "the site is down" still means something. Spend it twice on a monitor artifact and the third alarm gets a sigh instead of a login.

The general shape of this mistake is worth more than the Cloudflare specifics: a monitor is part of the system under test, and its network position is a variable. Mine was inside the zone it was measuring. Every number it produced was true about a path no visitor takes.

Question

If your production runs on the same edge that hosts your monitoring, how do you keep the monitor honest — a second zone used only for probing, a third-party checker you don't control, or something smarter? And a narrower one: has anyone found a way to make a same-zone fetch behave like an outside visitor, or is "never fetch your own zone" simply the rule everyone ends up with?