Both sides reproduced in our lab, 18 November 2026 — one address refused, another browsing; nginx 1.26.3, PHP-FPM 8.4.27.
Three tests settle whose fault a 503 is — run them before blaming anyone:
- Open the site on a different network (phone data, not your Wi-Fi). Works there? The refusal targets your address or network.
- Ask an outside checker what it sees. Our 503 Checker fetches from a third network entirely.
- Wait out the
Retry-After, then retry once. Healed everywhere at once? The origin fixed itself — it was the server.
Case 1: Only Your Address Is Refused
A server rule can refuse one source and welcome another.
Rate limits, geo rules, and firewalls all work this way.
We configured exactly that refusal in the lab.
One test address was marked blocked; the other was not.
Same page, same minute, two opposite answers:
From the normal address: 200 — page served
From the blocked address: 503 — VISITOR-BLOCKED: this source address is refused by a server rule.
The origin’s log proved where the refusal happened.
Only the welcomed request ever reached the application.
The refused one died at the edge, leaving no error line.
To the blocked visitor, the site looks simply down.
To everyone else, nothing is wrong at all.
Your tell: the site works on mobile data, fails on Wi-Fi.
Or the reverse — networks, not devices, draw the line.
Whose fault? The rule is the server’s; the trigger is your address.
Only the owner can lift it, so report it with your IP and timestamp.
The visitor playbook for this case is the as-a-visitor guide.
Case 2: Only Your Copy Is Stale
A healed site can keep failing for exactly one audience.
The mechanism is a cache holding the old 503.
We put a caching layer in front of a lab site.
Then we switched the origin into maintenance, once.
The first request fetched a genuine 503 from the origin.
The cache stored it, marked valid for sixty seconds.
We healed the origin immediately and asked again:
Origin, asked directly: 200 OK
Same visitor, via cache: 503 — X-Cache: HIT
The server was innocent and the visitor still saw failure.
Neither side was lying about what it saw.
One honest surprise from this run deserves print.
Adding a random query string busted our lab’s cache.
Its cache key included the full address, query and all.
Keys that ignore the query would have served the stale 503.
So the old trick works sometimes — measurably, not magically.
The tell: one network or browser fails, others pass.
And an outside checker reports the site healthy.
Whose fault? The cache’s configuration — usually the site’s CDN.
Patience or a purge fixes it; nothing you own is broken.
Case 3: It Really Is the Server
Sometimes every test agrees, instantly: the origin is failing.
Our saturated-pool run is the clean reference.
Three workers, twelve slow requests, one queue.
Every source would have met the same wall there.
No address was special; the capacity simply ran out.
The FPM log even announced it: server reached pm.max_children.
Maintenance mode is the deliberate version of the same case.
Our switch file answered 503 to ordinary visitors.
Every one of them, until the file was removed.
The next request after removal answered 200 again.
Your signal: all networks fail, the checker fails too.
And the failure heals everywhere in the same minute.
Whose fault? The server’s — or its owner’s schedule.
Nothing on your side changes the outcome.
The nine server-side mechanisms are catalogued in what causes a 503 error.
The Awkward Middle: The Owner Sees a Healthy Site
One lab configuration produced a genuinely unfair argument.
Our maintenance switch exempted the owner’s own address.
The owner browsed a healthy 200 the entire time.
Every ordinary visitor received the 503 maintenance page.
Both sides swore the other was imagining it.
Exemptions like this are common and usually deliberate.
Admin IPs get whitelisted so work can continue during incidents.
The trap springs when the incident is the exemption’s blind spot.
If a site owner insists their site is up, believe both reports.
Ask what an outside tool sees instead of arguing screenshots.
That third fetch is the referee — it shares neither side’s context.
Run it from our homepage or any status checker.
The Verdict Table
| What you observe | Most likely side | Why |
|---|---|---|
| Works on mobile data, fails on Wi-Fi | Your network is refused | Rules refuse addresses, not people |
| Fails for you; checker says healthy | A cache on your path | Stale copies outlive the fix briefly |
| Fails everywhere, heals everywhere together | The server | Capacity or maintenance at the origin |
| Owner sees 200, visitors see 503 | The server’s exemption | Whitelisted addresses skip the refusal |
| Instant 503, only on some pages | The server’s rules | Limits and rules are path-specific |
| Slow failure after ~30 s, all pages | The server’s capacity | Queues form behind busy workers |
Our standing verdict rule: two independent networks beat ten opinions.
Run the second-network test before any other conclusion.
It takes twenty seconds and settles most arguments outright.
What Did Not Work
Judging by one screenshot. Both lab sides had honest screenshots.
Each proved the opposite conclusion about the same minute.
Assuming a query string always busts cache. Ours did — by configuration.
A different key design would have ignored it completely.
We now write “sometimes” where we once wrote “trick”.
Checking the origin’s error log for edge refusals.
The blocked-visitor run left zero error lines at the origin.
Silence there means the refusal happened upstream, not innocence.
Blaming the visitor’s browser first.
Every “visitor-side” case here was a server rule or cache.
The browser was the messenger in all three reproductions.

FAQ
A site gives me 503 but my friend can open it. Who is right?
Both of you. A rule is refusing your address or network.
Or a cache on your path still holds the old error.
Run the verdict table above to separate the two.
Can a 503 be caused by my own internet provider?
Indirectly, yes. Providers share addresses through NAT.
One abusive neighbour can get the shared address rate-limited.
Your requests then inherit a refusal you did nothing to earn.
The owner says the site is fine. What do I send them?
A timestamp, your public IP, and the failing address.
Plus what an outside checker reported at that minute.
That bundle ends most “works for me” standoffs.
How long can a stale 503 outlive the fix?
As long as the cache entry stays valid — sixty seconds here.
Real CDN configurations range from seconds to far longer.
The Retry-After and cache headers on the response tell you.
Is a 503 ever the visitor’s own device?
Almost never in our reproductions.
A local firewall or security tool can block a site privately.
That case fails on one device across all networks — test that way.
Sources and date: all cases reproduced 18 November 2026 on nginx 1.26.3 and PHP-FPM 8.4.27 (Debian 13); timings and log behaviour quoted from those runs.
Status and header semantics follow RFC 9110; the checker behaviour described is our own tool, tested the same day.

Leave a Reply