A hands-on Kubernetes lab demonstrating why healthy Pods, successful rollouts, and working business operations are not the same thing.
A Kubernetes Deployment can report a successful rollout while a business-critical endpoint is returning HTTP 503.
No broken YAML. No crashing container. No failed readiness probe.
Just an application that Kubernetes considers available but cannot perform an important operation.
This is not necessarily a Kubernetes bug. It is a misunderstanding of what Kubernetes actually guarantees.
A successful rollout is an infrastructure-level observation, not an end-to-end verification of business functionality.
I wanted to demonstrate this distinction with something more useful than a theoretical explanation.
So I built a reproducible Kubernetes lab, deliberately introduced four different failure scenarios, observed how Kubernetes responded, and verified the recovery process.
The experiments were executed on Kubernetes 1.37.0 using Kind. The repository also includes a successful GitHub Actions workflow that independently validates the healthy deployment.
Let's walk through the architecture, experiments, and results.
1. What Kubernetes actually checks
Kubernetes provides three health probes, each with a different responsibility.
| Probe | Primary question | Consequence of repeated failure |
|---|---|---|
startupProbe | Has the application started? | Restart the container |
readinessProbe | Can this container receive traffic? | Mark the container unready and remove it from normal Service traffic eligibility |
livenessProbe | Should this container be restarted? | Restart the container |
These distinctions matter.
A liveness probe should not restart an otherwise functional application simply because a shared external dependency is temporarily unavailable.
A readiness probe should represent the application's ability to handle the traffic it is expected to receive.
And a startup probe can protect a slow-starting application from premature liveness restarts. When configured, it prevents readiness and liveness checks from executing until startup succeeds.
But none of these probes automatically understands your business logic.
Kubernetes knows what your application reports. It does not independently know whether a payment, booking, authentication, or order-processing workflow is correct.
Kubernetes manages the health signals we expose. It does not define what business health means for us.
2. Build a reproducible lab
We will deploy a deliberately simple Python HTTP server using a Kubernetes ConfigMap.
The application exposes four endpoints:
| Endpoint | Purpose |
|---|---|
/startup | Simulate successful application initialization |
/live | Report whether the process should remain running |
/ready | Report whether the application should receive traffic |
/checkout | Simulate an important business operation |
The server supports artificial failure flags stored in /tmp.
This allows us to demonstrate different failure modes without involving real databases, payment providers, or external infrastructure.
Requirements
You'll need:
- Docker
- Kind
- kubectl
- Git
- Sufficient resources for two application Pods
Use a disposable Kubernetes cluster. Do not execute these experiments against a production environment.
The complete source code is available here:
Kubernetes Production Readiness Lab — GitHub
Clone the repository
git clone https://github.com/rafaterrero/kubernetes-production-readiness-lab.git cd kubernetes-production-readiness-lab Create an isolated Kind cluster
We'll use a separate kubeconfig so the lab doesn't interfere with existing Kubernetes configurations.
mkdir -p "$HOME/.kube" export KUBECONFIG="$HOME/.kube/readiness-lab-kind.yaml" kind create cluster \ --name readiness-lab \ --image kindest/node:v1.37.0 \ --kubeconfig "$KUBECONFIG" \ --wait 180s This command assumes a cluster with that name doesn't already exist.
Verify the context:
kubectl config current-context kubectl get nodes Expected context:
kind-readiness-lab A single-node Kind cluster is sufficient for this experiment, provided it has enough resources for the original Pod and the additional Pod created during a rolling update.
The application manifest
The repository includes the complete manifest at:
manifests/readiness-lab.yaml
For clarity, here is the actual configuration used in the experiments:
apiVersion: v1 kind: Namespace metadata: name: readiness-lab --- apiVersion: v1 kind: ConfigMap metadata: name: probe-demo-code namespace: readiness-lab data: app.py: | import os from pathlib import Path from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer class Handler(BaseHTTPRequestHandler): def do_GET(self): routes = { "/startup": True, "/live": not Path("/tmp/not-live").exists(), "/ready": ( os.getenv("READY_ON_START", "true") == "true" and not Path("/tmp/not-ready").exists() ), "/checkout": not Path("/tmp/checkout-down").exists(), } if self.path not in routes: status = 404 else: status = 200 if routes[self.path] else 503 self.send_response(status) self.send_header("Content-Type", "text/plain") self.end_headers() self.wfile.write( f"{self.path}: {status}\n".encode() ) ThreadingHTTPServer( ("0.0.0.0", 8080), Handler ).serve_forever() --- apiVersion: apps/v1 kind: Deployment metadata: name: readiness-demo namespace: readiness-lab spec: replicas: 1 revisionHistoryLimit: 3 minReadySeconds: 5 progressDeadlineSeconds: 90 strategy: type: RollingUpdate rollingUpdate: maxSurge: 1 maxUnavailable: 0 selector: matchLabels: app: readiness-demo template: metadata: labels: app: readiness-demo spec: containers: - name: web image: python:3.12-alpine command: - python - -u - /app/app.py env: - name: READY_ON_START value: "true" ports: - name: http containerPort: 8080 volumeMounts: - name: code mountPath: /app readOnly: true startupProbe: httpGet: path: /startup port: http periodSeconds: 2 timeoutSeconds: 2 failureThreshold: 30 readinessProbe: httpGet: path: /ready port: http periodSeconds: 3 timeoutSeconds: 2 failureThreshold: 1 livenessProbe: httpGet: path: /live port: http periodSeconds: 5 timeoutSeconds: 2 failureThreshold: 3 volumes: - name: code configMap: name: probe-demo-code --- apiVersion: v1 kind: Service metadata: name: readiness-demo namespace: readiness-lab spec: selector: app: readiness-demo ports: - name: http port: 80 targetPort: http A few configuration decisions are intentional.
maxUnavailable: 0 prevents the rolling update from intentionally reducing the number of available replicas below the desired count.
maxSurge: 1 permits one additional Pod during the update. The cluster therefore needs enough resources for that extra Pod.
minReadySeconds: 5 requires a newly ready Pod to remain ready for five seconds before it counts as available.
progressDeadlineSeconds: 90 defines the Deployment controller's deadline for detecting stalled progress.
These settings influence rollout behavior.
They do not validate business functionality.
Deploy the application
From the repository root:
kubectl apply -f manifests/readiness-lab.yaml kubectl -n readiness-lab rollout status \ deployment/readiness-demo \ --timeout=240s kubectl -n readiness-lab get deployments,pods,svc The rollout should finish successfully, assuming the image can be pulled and the cluster has sufficient resources.
In my verified environment, the initial Deployment reached:
NAME READY UP-TO-DATE AVAILABLE readiness-demo 1/1 1 1 Verify the baseline
Instead of relying on a local port-forward, we can query the application through its Kubernetes Service from inside the cluster.
kubectl -n readiness-lab exec -i \ deployment/readiness-demo -- python - <<'PY' from urllib.request import urlopen base = "http://readiness-demo.readiness-lab.svc.cluster.local" for path in ("/ready", "/checkout"): with urlopen(base + path, timeout=5) as response: print(f"{path}: HTTP {response.status}") PY Expected result:
/ready: HTTP 200 /checkout: HTTP 200 This verifies Service DNS resolution and HTTP access through the Kubernetes Service from a Pod.
It does not, by itself, validate access from external clients.
We now have a healthy baseline.
3. Failure mode #1: A healthy Deployment with broken business functionality
Let's simulate a business-operation failure.
kubectl -n readiness-lab exec \ deployment/readiness-demo \ -- touch /tmp/checkout-down This creates a flag inside the application container.
The application will now return HTTP 503 from /checkout, while /ready remains unaffected.
Inspect both endpoints
kubectl -n readiness-lab exec -i \ deployment/readiness-demo -- python - <<'PY' from urllib.request import urlopen from urllib.error import HTTPError for path in ("/ready", "/checkout"): try: with urlopen( f"http://127.0.0.1:8080{path}", timeout=5 ) as response: status = response.status except HTTPError as exc: status = exc.code print(f"{path}: HTTP {status}") PY Actual result observed:
/ready: HTTP 200 /checkout: HTTP 503 Now inspect the Deployment:
kubectl -n readiness-lab get deployments kubectl -n readiness-lab get pods The actual output showed:
NAME READY UP-TO-DATE AVAILABLE readiness-demo 1/1 1 1 And the Pod remained:
READY STATUS RESTARTS 1/1 Running 0 What happened?
The readiness probe continued succeeding because /ready was unaffected.
The liveness probe continued succeeding too.
From Kubernetes' perspective, the application had not reported a health problem.
Yet our simulated business operation was failing.
This is the central lesson of the lab: Pod readiness is only as meaningful as the application-level conditions it represents.
There is no universal rule that every business operation must be part of readiness.
In fact, making readiness depend on every external integration can create other problems.
Imagine every replica failing readiness simultaneously because a shared payment provider experiences a brief outage.
Removing all Pods from Service routing might turn a partial failure into a broader outage.
A more robust design could keep the application available for unaffected operations, return a controlled error for the failed integration, and alert the relevant team.
The correct readiness contract depends on the application's responsibilities.
We should therefore distinguish between:
- Infrastructure availability.
- Application readiness.
- Dependency health.
- Business functionality.
- User-facing reliability.
These are related signals, not interchangeable ones.
Restore functionality
kubectl -n readiness-lab exec \ deployment/readiness-demo \ -- rm /tmp/checkout-down 4. Failure mode #2: Readiness failure without container restart
Now let's simulate an application that is running but temporarily unable to receive traffic.
kubectl -n readiness-lab exec \ deployment/readiness-demo \ -- touch /tmp/not-ready Wait for Kubernetes to detect the condition:
kubectl -n readiness-lab wait \ --for=condition=Ready=false \ pod -l app=readiness-demo \ --timeout=45s Inspect the Pod and Deployment
kubectl -n readiness-lab get pods kubectl -n readiness-lab get deployments Observed results:
NAME READY STATUS RESTARTS readiness-demo-6b9f5b684b-44hnp 0/1 Running 0 And:
NAME READY UP-TO-DATE AVAILABLE readiness-demo 0/1 1 0 The container had not restarted.
The process was still running.
But Kubernetes no longer considered the Pod ready to receive normal Service traffic.
Inspect the EndpointSlice
kubectl -n readiness-lab get endpointslices \ -l kubernetes.io/service-name=readiness-demo \ -o yaml The actual EndpointSlice contained:
conditions: ready: false serving: false terminating: false The endpoint still existed in the EndpointSlice, but it was no longer eligible for normal Service routing.
With only one replica, our Service had no ready backend.
In a multi-replica workload, other ready replicas could continue serving traffic.
This distinction is particularly important during rolling updates and temporary application initialization.
Readiness failure changes traffic eligibility. It does not necessarily require restarting the process.
Restore readiness
kubectl -n readiness-lab exec \ deployment/readiness-demo \ -- rm /tmp/not-ready Wait for recovery:
kubectl -n readiness-lab wait \ --for=condition=Ready \ pod -l app=readiness-demo \ --timeout=45s kubectl -n readiness-lab rollout status \ deployment/readiness-demo \ --timeout=60s In the verified experiment, readiness recovered without a container restart.
5. Failure mode #3: A rollout blocked by readiness
Now let's simulate releasing a version that starts but never becomes ready.
Our Deployment has:
replicas: 1 strategy: type: RollingUpdate rollingUpdate: maxSurge: 1 maxUnavailable: 0 This allows Kubernetes to create an additional Pod while preserving the previous available replica.
It is an important property, but not an unconditional zero-downtime guarantee.
Introduce a defective version
Change the environment variable in the Deployment template:
kubectl -n readiness-lab set env \ deployment/readiness-demo \ READY_ON_START=false This triggers a new rollout.
The new Pod starts.
Its /startup and /live endpoints remain healthy.
However, /ready returns HTTP 503.
Inspect the Pods
kubectl -n readiness-lab get pods \ -l app=readiness-demo In my experiment, the new and previous versions coexisted:
NAME READY STATUS readiness-demo-65f8578575-qp4gg 0/1 Running readiness-demo-6b9f5b684b-44hnp 1/1 Running The previous version remained available.
The new version was running but never became ready.
Wait for the failed rollout
kubectl -n readiness-lab rollout status \ deployment/readiness-demo \ --timeout=130s Because the new replica remains unavailable, the Deployment controller should eventually exceed its configured 90-second progress deadline.
The actual result was:
Waiting for deployment "readiness-demo" rollout to finish: 1 old replicas are pending termination... error: deployment "readiness-demo" exceeded its progress deadline Two different timeouts
There is an important distinction here.
The --timeout=130s option belongs to the kubectl client. It limits how long the command waits.
The Deployment's progressDeadlineSeconds: 90 belongs to the Kubernetes controller. It determines when the controller reports stalled rollout progress.
A client-side timeout does not automatically mean Kubernetes has declared the Deployment failed.
That is why we should inspect the controller's actual conditions.
Inspect the Deployment state
kubectl -n readiness-lab describe \ deployment readiness-demo The verified experiment reported:
Replicas: 1 desired | 1 updated | 2 total | 1 available | 1 unavailable And:
Type Status Reason ---- ------ ------ Available True MinimumReplicasAvailable Progressing False ProgressDeadlineExceeded This is one of the most interesting observations of the entire lab.
The Deployment was still available.
But its latest rollout had failed.
In other words:
Available=True does not mean the newest Deployment revision was successfully rolled out.
The previous healthy version was maintaining availability while Kubernetes reported that the update could not progress.
Verify the Service endpoints
kubectl -n readiness-lab get endpointslices \ -l kubernetes.io/service-name=readiness-demo \ -o jsonpath='{range .items[*].endpoints[*]}{.targetRef.name}{" ready="}{.conditions.ready}{"\n"}{end}' Observed result:
readiness-demo-6b9f5b684b-44hnp ready=true readiness-demo-65f8578575-qp4gg ready=false The old version remained eligible for Service traffic.
The new version did not.
Roll back the failed revision
kubectl -n readiness-lab rollout undo \ deployment/readiness-demo This restores the previous Pod template.
However, it does not automatically reverse external side effects such as database migrations or changes to shared state.
A Kubernetes rollback is not necessarily an application rollback.
There is another operational detail worth highlighting.
Immediately after rollout undo, my first rollout status check still reported the previous progress-deadline failure.
But the previous healthy Pod was already available.
A subsequent inspection showed that the Deployment controller had completed reconciliation.
We can inspect the relevant conditions with:
kubectl -n readiness-lab get deployment readiness-demo \ -o jsonpath='{range .status.conditions[*]}{.type}{" = "}{.status}{" | "}{.reason}{"\n"}{end}' And verify the desired generation:
kubectl -n readiness-lab get deployment readiness-demo \ -o jsonpath='generation={.metadata.generation} observed={.status.observedGeneration} replicas={.status.replicas} updated={.status.updatedReplicas} available={.status.availableReplicas}{"\n"}' The recovered Deployment reported:
Available = True | MinimumReplicasAvailable Progressing = True | NewReplicaSetAvailable And:
generation=3 observed=3 replicas=1 updated=1 available=1 The defective ReplicaSet had been scaled to zero.
One additional consideration: kubectl rollout undo does not update the last-applied-configuration annotation used by kubectl apply. Subsequent declarative changes should account for this distinction.
The lesson is clear:
Initiating a rollback is not the same as verifying successful recovery.
A release pipeline should confirm the intended revision, controller conditions, available replicas, and application behavior before declaring recovery complete.
6. Failure mode #4: Liveness failure and automatic restart
So far, we have intentionally avoided using liveness to detect temporary readiness or business-functionality failures.
Now let's demonstrate what happens when liveness actually fails.
Inject a liveness failure
kubectl -n readiness-lab exec \ deployment/readiness-demo \ -- touch /tmp/not-live The /live endpoint now returns HTTP 503.
Our Deployment uses:
livenessProbe: httpGet: path: /live port: http periodSeconds: 5 timeoutSeconds: 2 failureThreshold: 3 After three consecutive failures, kubelet should restart the container.
Observe the restart
kubectl -n readiness-lab get pods -w Stop watching with Ctrl+C after recovery.
Then inspect the Pod:
kubectl -n readiness-lab describe pods \ -l app=readiness-demo The actual result showed that the container restart count increased:
RESTARTS 1 The kubelet events provided the reason:
Warning Unhealthy Liveness probe failed: HTTP probe failed with statuscode: 503 Normal Killing Container web failed liveness probe, will be restarted The previous container had:
Last State: Terminated Reason: Error Exit Code: 137 Exit code 137 alone does not prove an out-of-memory failure.
In this experiment, the kubelet events explicitly identified the failing liveness probe as the reason for the restart.
After restarting, the Pod recovered:
READY STATUS RESTARTS 1/1 Running 1 The temporary failure flag disappeared because it was stored in the container's writable filesystem.
Why this distinction matters
In production, a failing liveness probe might indicate a deadlock or another condition from which restarting the process is an appropriate recovery action.
But restarting an application because a remote database is temporarily unavailable can be counterproductive.
If the shared dependency is failing, indiscriminately restarting every dependent application could increase load, erase useful in-memory state, and slow recovery.
Liveness is a recovery mechanism, not a general-purpose dependency monitor.
7. The missing layer: Post-deployment verification
Our first experiment demonstrated a problem Kubernetes health probes alone did not detect.
The application was ready, but an important operation failed.
This is where deployment verification must move beyond infrastructure signals.
A simple release gate should verify both the Kubernetes state and representative application behavior.
Check rollout status
kubectl -n readiness-lab rollout status \ deployment/readiness-demo \ --timeout=180s This confirms that the rollout has completed according to the Deployment controller.
It does not verify business functionality.
Verify an application endpoint through the Service
For our lab, we can query the simulated business endpoint using Kubernetes Service DNS.
kubectl -n readiness-lab exec \ deployment/readiness-demo -- \ python -c 'from urllib.request import urlopen; print(urlopen("http://readiness-demo.readiness-lab.svc.cluster.local/checkout", timeout=5).status)' A successful response prints:
200 These checks answer different questions.
The first asks whether the Kubernetes rollout completed.
The second asks whether a particular application operation is functioning.
For this experiment, the endpoint represents a safe synthetic operation.
In production, application-level checks should exercise representative functionality without causing unwanted side effects.
Additional verification layers
A production-grade verification process might include:
| Layer | Example verification |
|---|---|
| Deployment | Desired replicas updated and available |
| Application | Synthetic transaction or critical API request |
| Reliability | Error rate, latency, availability |
| Dependencies | Connectivity and dependency-specific behavior |
| Data | Schema and version compatibility |
| Security | Expected authentication and authorization behavior |
| Rollback | Known recovery procedure and compatibility checks |
Depending on the service, the process can also include canary releases, progressive traffic shifting, automated analysis of service-level indicators, and human approval for high-risk changes.
There is no universal release gate.
But there should be an explicit difference between:
- Kubernetes accepted this version.
- The application passed our operational acceptance criteria.
8. Automating healthy-state verification
The repository includes a verification script:
scripts/verify.sh
It checks:
- The expected Kubernetes context.
- Deployment rollout status.
- Deployment and Pod state.
- The
/readyand/checkoutendpoints. - EndpointSlice readiness.
Execute it from the repository root:
export KUBECONFIG="$HOME/.kube/readiness-lab-kind.yaml" ./scripts/verify.sh The script was executed successfully in the original lab.
Its final output included:
=== Application Service Check === /ready: HTTP 200 /checkout: HTTP 200 === EndpointSlices === readiness-demo-6b9f5b684b-44hnp ready=true Healthy application verification completed. The script verifies the healthy state.
It does not intentionally introduce failures.
The four failure scenarios are documented separately for manual reproduction.
Independent verification using GitHub Actions
To make the lab independently reproducible, I also added a GitHub Actions workflow.
The workflow:
- Checks out the repository.
- Creates a fresh Kind cluster.
- Verifies the Kubernetes context.
- Deploys the application.
- Waits for the rollout.
- Executes
scripts/verify.sh. - Collects diagnostics if a step fails.
The first GitHub Actions execution completed successfully.
You can inspect the actual run here:
Successful Kubernetes Readiness Lab CI execution
This independently verifies the healthy deployment.
The four failure-injection scenarios were validated manually in the original Kind cluster and are not yet automated in CI.
That distinction matters: a green CI pipeline proves only what its tests actually exercise.
9. Production recommendations
Here are the principles I would apply when designing readiness and deployment controls for critical services.
Define probe contracts with application developers
A platform team should not guess what application readiness means.
The application owner should establish which internal conditions prevent the service from handling its intended traffic.
Separate temporary unavailability from process failure
Readiness can stop traffic without forcing a restart.
Liveness should be reserved for failures where restarting is an appropriate recovery mechanism.
Use startup probes where startup time is variable
They provide an explicit startup window instead of forcing liveness checks to tolerate lengthy initialization.
Treat successful rollouts as necessary but insufficient evidence
Deployment status should be combined with application-specific validation.
Design rollback before release
Consider configuration changes, schema compatibility, messages in queues, persistent state, and external dependencies.
Validate the deployment strategy against real capacity
maxSurge requires additional resources.
maxUnavailable constrains availability during rolling updates.
Neither setting alone proves zero downtime.
Harden the workload independently of health checks
Our lab uses a convenient Python image and an intentionally minimal manifest.
A production deployment should additionally consider:
- Pinned image versions or digests.
- Resource requests and limits.
- Non-root execution.
- Restricted container permissions.
- Dependency management.
- Network policies.
- Supply-chain controls.
- Suitable logging and observability.
Health probes do not replace these safeguards.
10. What this means for Platform Engineering
A Platform Engineering team should aim to make reliable deployment practices reusable.
Instead of forcing every development team to reinvent probes, release validation, rollback procedures, and observability, an internal platform can establish sensible defaults and clear extension points.
That might include:
- Standardized deployment templates.
- Documented probe contracts.
- Reusable post-deployment verification.
- Consistent metrics, logs, and traces.
- Progressive delivery capabilities.
- Automated and manual recovery procedures.
The objective is not to hide every operational decision from developers.
It is to reduce unnecessary complexity while making the important decisions visible, testable, and repeatable.
A good internal platform should make the safe path easier to follow, not merely provide more YAML to maintain.
11. Verified Lab Results — Kubernetes 1.37.0
All four failure scenarios described in this article were executed on a disposable Kind cluster running Kubernetes 1.37.0, hosted on Ubuntu 24.04 with Docker 29.10.0.
The results below are actual observations from the lab, not fabricated terminal outputs or production benchmarks.
| Experiment | Verified result |
|---|---|
| Business failure | /ready returned HTTP 200 while /checkout returned HTTP 503. The Deployment remained available. |
| Readiness failure | The Pod became 0/1 Ready without restarting. Its EndpointSlice reported ready=false and serving=false. |
| Failed rollout | The new Pod remained unready while the previous Pod stayed available. Kubernetes reported ProgressDeadlineExceeded. |
| Rollback | The healthy template was restored. The Deployment subsequently reported Progressing=True with NewReplicaSetAvailable. |
| Service recovery | Both /ready and /checkout returned HTTP 200 through Kubernetes Service DNS. |
| Liveness failure | Three HTTP 503 probe failures triggered a container restart. The Pod recovered with Ready=True. |
| CI verification | GitHub Actions successfully deployed and verified the healthy application in a separate Kind cluster. |
A particularly important observation
During the failed-rollout experiment, the Deployment simultaneously reported:
Available = True Progressing = False Reason = ProgressDeadlineExceeded The previous Pod was still eligible for Service traffic.
The newest Pod was not.
This demonstrates that application availability and deployment progression are separate operational signals.
During recovery, another distinction became visible.
Immediately after initiating the rollback, the rollout status command still reported the earlier failure.
Only after the controller reconciled the restored revision did the Deployment report:
Available = True | MinimumReplicasAvailable Progressing = True | NewReplicaSetAvailable This reinforces why rollback initiation and verified recovery must be treated as separate steps.
12. Reproduce the experiments
The complete source code, Kubernetes manifests, experiment instructions, and verified results are publicly available:
Kubernetes Production Readiness Lab — GitHub
The repository includes:
| File or directory | Purpose |
|---|---|
manifests/readiness-lab.yaml | Kubernetes application and probes |
scripts/verify.sh | Healthy-state validation |
docs/architecture.md | Architecture and deployment strategy |
docs/experiments.md | Instructions for all four experiments |
docs/verified-results.md | Results observed in the original lab |
evidence/final-recovery.txt | Captured final recovery state |
.github/workflows/kind-smoke.yml | GitHub Actions verification workflow |
The project is open source under the MIT License.
Cleanup
When you finish the experiments, remove the lab namespace:
kubectl delete namespace readiness-lab This removes the application resources from the test cluster.
You can also delete the entire disposable Kind cluster:
kind delete cluster --name readiness-lab The original testing environment was cleaned up after validation. The source code and documented evidence remain available in GitHub.
Final thoughts
Kubernetes is very good at managing desired state.
It can schedule Pods, restart unhealthy containers, update replicas, and manage traffic eligibility based on readiness.
But its view of application health depends on the signals and contracts we provide.
Our experiments demonstrated that:
- A Deployment can be available while a critical business operation fails.
- A container can be alive without being ready.
- A Pod can be ready while an external integration is broken.
- A Dep...

