Skip to content
Control Plane Labs

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:

  • /startup returns 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.
  • /ready checks 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.
  • /live checks 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

  1. Measure container-start-to-Ready times across several rollouts and nodes, and keep the maximum.
  2. Add a startup probe if that maximum is long or variable. Set periodSeconds to 5 or less and failureThreshold so the budget is about 1.3 to 1.5 times the maximum.
  3. Keep liveness strict after startup, and point it at an endpoint that only checks the process.
  4. Use readiness for temporary unavailability and keep its threshold short.
  5. 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?+
A startupProbe runs only during startup, holds off liveness and readiness checks until it succeeds, and restarts the container if it fails too often. A readinessProbe runs for the container's whole life and removes the Pod from Service endpoints when it fails, without restarting it.
Do readiness and liveness probes run while the startup probe is running?+
No. Kubernetes does not run liveness or readiness probes until the startup probe has succeeded. After that, the startup probe stops and the other two take over.
How long should a startup probe allow?+
Measure the worst-case time from container start to Ready across several rollouts and nodes, then set failureThreshold × periodSeconds to about 1.3 to 1.5 times that. A much larger budget delays restarts of containers that hang during initialization.
What happens when a startup probe fails?+
After failureThreshold consecutive failures, the kubelet kills the container and applies the Pod's restart policy. Repeated failures put the container into exponential restart backoff, which starts at 10 seconds and is capped at 300 seconds by default.
Should the startup probe check the database?+
Usually not. A startup or liveness failure restarts the container, so those checks should only fail when a restart would help. Put dependency checks in the readiness probe, where failure only removes the Pod from rotation.
Can I use initialDelaySeconds instead of a startup probe?+
It works only if startup time is short and predictable. A fixed delay kills containers that start slower than usual, and it delays deadlock detection after every restart. A startup probe adapts to the actual start time.
Does a sidecar's startup probe delay the main container?+
For native sidecars (init containers with restartPolicy: Always), yes. The kubelet starts the next init container, and eventually the app containers, only after the sidecar's startup probe succeeds.

Tags: #kubernetes, #probes, #startupprobe, #readinessprobe, #livenessprobe, #deployments, #sre