Build1 distinct publisher3 min readPublished
A dev.to explainer works through what liveness, readiness and startup probes each actually answer. Its argument is that an all-green rollout hiding a broken checkout is a category gap that more probes cannot close.
The Engineer · Build desk
Compiled by The EngineerSomething wrong?How this is made
Follow any of these and your For You feed starts watching them — no settings page required.
build
A Dockerfile HEALTHCHECK gates traffic only when Swarm is the orchestrator1 distinct publisher
build
A dependency check in the liveness probe turns one outage into two1 distinct publisher
build
SSE in Go breaks twice before your handler runs: an illegal header, then a 30-second timeout1 distinct publisher
build
Rate limit your MCP servers, because a retrying agent turns one error into a billing incident1 distinct publisher
The probe contract, read literally, explains the surprise. A liveness probe reports whether the process has deadlocked or hung badly enough to fail its own restart threshold, and a readiness probe reports only that the process is willing to accept traffic right now [3][4]. The startup probe exists so the kubelet does not evaluate either of those before initialization finishes [5]. That is three checks on the state of a process, none of which runs business logic [18].
A stale connection to a downstream queue walks through all three without touching any of them. In the author's account of the incident pattern, the readiness probe on the checkout service never checked whether the service could reach the fulfillment queue; it checked whether the process was up, and the process was up [10].
Each of these checks was built to answer a cheap, fast, narrow question rather than an expensive, slow, broad one, and the author's position is that the tradeoff is usually correct [11]. Cheap and fast has teeth. A check that re-dialled the queue every poll interval would be neither, and the kubelet keeps polling for the life of the pod.
What the material does not contain is a postmortem. The forty-minute checkout failure is introduced as the scenario that makes the argument concrete [8]. The one instance pointed at outside the article is the Network Loop in the Rack2Cloud Method's Day-2 operations guide, which the author says documents the same failure mode from the routing side, a misconfigured readiness probe sending traffic to a pod that cannot actually serve it [12]. The article counts six control points where a passing signal hides a real failure, and readiness is the row it develops in the text [14]. So the probe semantics are documented and the forty minutes is an illustration.
For the pattern to transfer to your cluster, two things have to hold at once. The dependency is established once at startup and never re-validated on the serving path [9]. And the probe endpoint does not touch that dependency [10]. Break either condition and the failure stops being invisible: a handler that opens the connection per request and returns a 500 when it cannot shows up in the error rate you already graph, not in the replica count.
Nothing in the orchestration layer was lying in this scenario. The rollout genuinely succeeded by every metric Kubernetes tracks [17]. The dashboard answered the question it was asked, accurately: it confirmed that replicas were ready to receive traffic, not that a checkout could complete. I would act on the mechanism and treat the forty minutes as a teaching example until someone publishes the timeline.
Ranked by verification strength, evidence, and original report placement.
The article presents its checkout failure as 'the scenario that makes this concrete': a deployment rolls out, every readiness probe passes within its configured threshold, the rollout controller reports success, and the dashboard shows 100% of replicas ready, zero restarts, and latency within SLO.
In that scenario, forty minutes later support tickets arrive: users click place order, get a spinner, and the order never appears in the downstream fulfillment system, because the queue connection established once at startup and never re-validated had gone stale after a network policy change nobody connected to the deployment.
The readiness probe on the checkout service never checked whether it could reach the fulfillment queue; it checked whether the process was up, and the process was up.
Nothing in the orchestration layer was lying in the scenario; the rollout genuinely succeeded by every metric Kubernetes tracks.
Kubernetes health checks tell you whether a workload satisfies the narrow condition the probe was designed to test, not whether the business objective the workload exists to serve actually happened.
Passing health checks prove participation in orchestration; they do not prove the intended outcome occurred.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · September 4, 2026
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Sound on probe mechanics, thin everywhere else
The load carried by this story splits cleanly. What liveness, readiness and startup probes each confirm is standard, verifiable kubelet behaviour, and dev.to states it correctly. Everything else is one author's reasoning: the checkout failure is an illustration with no cluster or postmortem behind it, the six control points are counted but never listed in the text we hold, and the corroborating Network Loop write-up is the author's own guide, which we cannot see.
Nothing deployed to count
This is an argument about how a signal is interpreted, not a thing anyone ships. Our coverage contains no release, rollout, benchmark, pricing move or usage disclosure — not even a named team reporting that it added outcome-level checks after being burned this way — so there is no adoption to measure and we decline to invent one.
One rhetorical stretch in an otherwise sober piece
Mostly this reporting undersells rather than oversells: it refuses to call Kubernetes broken, credits the control plane with doing its job well, and endorses the cheap-check tradeoff. The overshoot is narrow and specific — 'the severity isn't hypothetical' is asserted about a scenario that is hypothetical, and a failure mode gets promoted to a capitalised name with no evidence anyone outside this author uses it.
Every road leads back to the house method
The argument is real, and so is the funnel around it. Published under a consultancy handle, the post cites the Rack2Cloud Method's Day-2 guide as its corroborating case, sends readers to a companion Day-2 incidents post, and lands on a proprietary label for the failure mode. None of that makes the probe analysis wrong; it does mean the one piece of supporting evidence offered is also the thing being marketed.
Confident on the mechanism, not on the world
We can be fairly sure the reasoning is right — a probe cannot certify an outcome it never exercises, and that follows from what the probes do. We are much less sure how often this bites in production, because a single author's illustration is all our coverage offers, and no second outlet, incident record or operator account is here to check it against.