Kubernetes startupProbe vs readinessProbe
When to use a startupProbe, a readinessProbe, or both: size the startup budget from measured start times, and keep liveness able to catch real deadlocks.
Control Plane Labs Staff
Published November 3, 2026
Most probe problems come from asking one probe to do another’s job. A long initialDelaySeconds on liveness stands in for a startup probe. A readiness probe gets a ten-minute threshold because the app is slow on a cold cache. A startup budget gets set to an hour “to be safe,” and a container that hangs during init takes an hour to restart.
This guide covers what each probe controls, how to size a startup budget from data you already have, and the configurations that hide hangs instead of catching them. For debugging a readiness probe that is already failing, see our readiness probe debugging guide.
What each probe controls
The Pod lifecycle documentation defines three probes with three different consequences:
| Probe | Runs | On failure | Use it to answer |
|---|---|---|---|
startupProbe |
Only at startup, until it succeeds once | The kubelet kills the container, and the restart policy applies | Has initialization finished? |
readinessProbe |
For the container’s whole life | The Pod’s IP is removed from the EndpointSlices of matching Services | Can it serve requests right now? |
livenessProbe |
After startup succeeds, for the container’s whole life | The kubelet restarts the container | Is it stuck and unable to make progress? |
The key detail is the hand-off. If a container has a startup probe, Kubernetes “does not execute liveness or readiness probes until the startup probe succeeds.” After that, the startup probe stops running, and the probe configuration guide says liveness “takes over to provide a fast response to container deadlocks.” The startup probe runs again only when a new container starts, for example after a restart.
Readiness doesn’t restart anything. A failing readiness probe takes the Pod out of rotation through EndpointSlices and puts it back when the probe passes again. That makes readiness the right tool for temporary conditions such as a warming cache, a dependency outage, or overload, and the wrong tool for detecting a process that will never recover.
When you need a startup probe
The startup probe was added under KEP-950 for one problem: containers that take a long or unpredictable time to start were being killed by liveness probes before they finished. The earlier workaround, a large initialDelaySeconds on liveness, has two costs. The delay is fixed, so a start that runs slower than usual still gets killed. And every restart waits out the full delay before liveness can detect anything.
Add a startup probe when any of these is true:
- Start time varies widely: JVM warm-up, migrations run at boot, loading a model or a large cache, or waiting on a sidecar.
- Start time grows with data size, so this month’s safe delay is next quarter’s restart loop.
- You want liveness to be strict (a few failures, short period) once the app is running.
If a container starts in a few seconds every time, you probably don’t need one. Readiness already keeps traffic away until the app is ready. With the defaults in the Pod API reference, a 10-second period and a failure threshold of 3, liveness tolerates about 30 seconds of failures before restarting. Note that successThreshold must be 1 for startup and liveness probes, and only readiness can require several consecutive successes.
Size the startup budget from measured start times
The probe guide’s rule is to set failureThreshold × periodSeconds “long enough to cover the worst case startup time.” In practice the kubelet first probes after initialDelaySeconds, so the total time before a startup-probe kill is roughly initialDelaySeconds + failureThreshold × periodSeconds. Leave initialDelaySeconds at 0 and control the budget with the other two fields. A short period means the probe passes soon after startup actually finishes.
Don’t guess the worst case. Your cluster already records it. For a Pod that hasn’t restarted, the time from container start to the Pod’s Ready condition covers the startup phase plus the first passing readiness check:
kubectl get pods -n web -l app=api -o json | jq -r '.items[]
| select(.status.containerStatuses[0].restartCount == 0)
| (.status.conditions[] | select(.type == "Ready" and .status == "True") | .lastTransitionTime) as $ready
| [.metadata.name, (($ready | fromdate) - (.status.containerStatuses[0].state.running.startedAt | fromdate))]
| @tsv'
We tested this filter on a saved Pod list with three Pods, one of which had restarted and wasn’t Ready:
api-7d9-abc 95
api-7d9-def 137
The restarted Pod is excluded because its Ready timestamp no longer lines up with the current container’s start. The lastTransitionTime field records the last status change, so a Pod that flapped later gives a misleading number. Collect samples across a few rollouts and node types. A cold node pulling a large image, or a Pod scheduled during a busy period, is your real worst case.
With a measured maximum of 137 seconds, a budget around 1.3 to 1.5 times that gives room for a slow node without letting a hung start sit for long:
startupProbe:
httpGet:
path: /startup
port: http
periodSeconds: 5
failureThreshold: 40 # 40 × 5s = 200s budget
timeoutSeconds: 2
readinessProbe:
httpGet:
path: /ready
port: http
periodSeconds: 5
failureThreshold: 2
timeoutSeconds: 2
livenessProbe:
httpGet:
path: /live
port: http
periodSeconds: 10
failureThreshold: 3 # about 30s to detect a deadlock after startup
timeoutSeconds: 2
Record the measured number next to the manifest. When start times grow, you’ll see the budget is out of date before the restart loop starts.
Separate endpoints for separate questions
The three probes should check different things, because their consequences are different:
/startupreturns success once initialization is done: migrations applied, config loaded, the listener bound. It shouldn’t check external dependencies that can fail later, because a database outage during a restart then becomes a restart loop./readychecks whether this instance can serve a request right now. It can include dependencies the request path really needs, since failing it only removes the Pod from rotation./livechecks only the process itself: an event loop that responds, worker threads that aren’t wedged. If it calls the database, a database outage restarts every Pod at once and turns a dependency problem into a full outage.
All three can share a handler for the cheap parts. The point is that a startup or liveness failure triggers a restart, so those endpoints should fail only when a restart would help.
Configurations that hide hangs
An oversized startup budget. A budget of an hour means a container that deadlocks during init sits for an hour before the kubelet acts. During a rollout, the Deployment won’t count the Pod as available. If progress stalls past progressDeadlineSeconds, 600 seconds by default, the Deployment controller marks the rollout Progressing=False with reason ProgressDeadlineExceeded. It reports the problem but doesn’t roll back, so the stall lasts until someone acts.
Readiness doing startup’s job. A readiness probe with a huge failureThreshold lets a slow start through, but it never restarts a container that hangs during init. The Pod stays Running and NotReady indefinitely. Readiness thresholds should reflect how long a healthy instance can be briefly unavailable, not how long startup takes.
Liveness with initialDelaySeconds instead of a startup probe. This works until startup gets slower than the delay. Then every Pod restarts just before it would have finished, and the container goes into backoff.
Ignoring restart backoff. When startup probes keep failing, restarts follow the kubelet’s exponential backoff of 10s, 20s, 40s and up, capped at 300 seconds, per the Pod lifecycle documentation. The KubeletCrashLoopBackOffMax feature, beta and on by default since 1.35, lets node administrators lower that cap. Either way, a budget that’s too small doesn’t fail fast. It fails, waits, and fails again, and the time to recover grows with each attempt.
Startup probes on native sidecars
Native sidecars, init containers with restartPolicy: Always, are stable since Kubernetes 1.33. Their startup probes affect ordering. The sidecar documentation says the kubelet starts the next init container only after the sidecar’s started status is true. That happens when its startupProbe succeeds, or as soon as its process is running if it has no startup probe. Because app containers start only after all init containers, a startup probe on a proxy or log shipper sidecar ensures it’s up before your application starts.
That’s usually what you want for a service mesh proxy. It also means the sidecar’s startup time adds to the app’s. Measure from Pod creation, not container start, when a sidecar is in the chain, and size the app’s own startup probe for the app alone.
Checklist
- Measure container-start-to-Ready times across several rollouts and nodes, and keep the maximum.
- Add a startup probe if that maximum is long or variable. Set
periodSecondsto 5 or less andfailureThresholdso the budget is about 1.3 to 1.5 times the maximum. - Keep liveness strict after startup, and point it at an endpoint that only checks the process.
- Use readiness for temporary unavailability and keep its threshold short.
- Re-measure when images, data sizes, or node types change, and update the budget.
Our kubectl cheat sheet has the commands for reading Pod conditions and events if you need to dig into a specific start.
Frequently asked questions
What is the difference between a startupProbe and a readinessProbe?+
Do readiness and liveness probes run while the startup probe is running?+
How long should a startup probe allow?+
What happens when a startup probe fails?+
Should the startup probe check the database?+
Can I use initialDelaySeconds instead of a startup probe?+
Does a sidecar's startup probe delay the main container?+
Tags: #kubernetes, #probes, #startupprobe, #readinessprobe, #livenessprobe, #deployments, #sre