Your App Is Running. Kubernetes Disagrees.

You deploy your side project to a Kubernetes cluster. Everything looks green. Then traffic stops. Your pods are restarting in a loop and you have no idea why. Kubernetes health checks, called probes, are often the silent culprit behind mysterious production outages.

Most tutorials show you how to deploy to Kubernetes. Very few explain what happens after deployment. Probes are the part that bites you later, usually at the worst possible time.

This guide covers what solo developers and indie hackers actually need to know. Not just the theory, but the practical configuration choices that keep your service alive.

The Three Probes and Why Each One Matters

Kubernetes runs three distinct types of probes. Each one does a different job in the container lifecycle. Mixing them up, or ignoring them entirely, leads to brittle deployments.

Startup Probes: Give Your App Time to Boot

A startup probe runs once when a container first starts. It tells Kubernetes to wait before checking anything else. This is critical for JVM-based apps, Python services with heavy imports, or anything that needs time to warm up a database connection pool.

Without a startup probe, your liveness probe fires immediately. A slow-starting app looks dead to Kubernetes. Kubernetes kills it. The pod restarts. The cycle repeats endlessly.

Here is a minimal startup probe configuration in YAML:

startupProbe:
  httpGet:
    path: /healthz
    port: 8080
  failureThreshold: 30
  periodSeconds: 10

This gives your app up to 300 seconds to start. Adjust failureThreshold based on your actual boot time. Measure it in staging first.

Liveness Probes: Restart When Truly Stuck

A liveness probe runs continuously throughout the container's life. When it fails, Kubernetes restarts the container. This is meant for situations where your app is running but completely stuck, like a deadlocked thread pool or an infinite loop.

The common mistake is pointing liveness probes at endpoints that check downstream dependencies. If your payment service calls an external API in its liveness check, a downstream hiccup kills your pods. Your service was fine. The probe made it look broken.

Keep liveness probes shallow. Check only that your process is alive and responsive. Nothing external.

Readiness Probes: Control Traffic, Not Restarts

A readiness probe is different in one critical way. When it fails, Kubernetes removes the pod from the load balancer. It does not restart the container. Traffic stops flowing to that pod until the probe passes again.

This is the right place to check downstream dependencies. If your database is unreachable, mark yourself as not ready. Stop taking traffic. Do not die. This distinction matters enormously for graceful degradation.

The Configuration Trap That Kills Payment Services

Here is where solo developers get burned. Kubernetes probe failures do not just affect routing. They can cascade into resource exhaustion. When probes fail repeatedly, Kubernetes schedules restarts. Each restart triggers a new JVM initialization, new connection pool creation, new cache warmup. Memory spikes. CPU spikes. More probes fail. More restarts.

This feedback loop is fast and brutal. A misconfigured readiness probe checking a flaky third-party API can take down a service that was otherwise perfectly healthy. The fix feels like adding memory. The real problem is probe design.

According to Ars Technica's infrastructure coverage, cascading failures in distributed systems often originate from monitoring and health check logic rather than core application bugs. The tooling meant to protect you becomes the threat.

Furthermore, if you are logging probe failures, check your log aggregation setup. Tools like a JSON Formatter can help you parse structured Kubernetes event logs quickly when you are under pressure during an incident.

What to Actually Configure as a Solo Developer

You are not running a 50-engineer platform team. You need sane defaults that work. Here is a practical starting point for a Node.js or Python web service:

startupProbe:
  httpGet:
    path: /health/startup
    port: 3000
  failureThreshold: 20
  periodSeconds: 5

livenessProbe:
  httpGet:
    path: /health/live
    port: 3000
  initialDelaySeconds: 0
  periodSeconds: 15
  failureThreshold: 3

readinessProbe:
  httpGet:
    path: /health/ready
    port: 3000
  periodSeconds: 10
  failureThreshold: 3

Notice three separate endpoints. Each does one job. /health/live returns 200 if the process responds. /health/ready checks your database connection and any critical dependencies. /health/startup confirms initialization is complete.

The AWS documentation on EKS health checks reinforces this separation of concerns. Different signals require different responses.

Tools That Help You Debug Probe Failures Fast

When a probe failure cascade starts, you have minutes to diagnose it. Having the right tools pre-configured saves your service.

kubectl describe pod [pod-name] shows recent probe failures with timestamps and failure reasons. Run this first.
kubectl logs [pod-name] --previous shows logs from the last crashed container. Invaluable for startup failures.
kubectl get events --sort-by=.lastTimestamp gives you a timeline of what Kubernetes did and when.
Datadog, Grafana, or Prometheus with alert rules on kube_pod_container_status_restarts_total catches restart loops early.
A structured logging setup that outputs JSON makes log parsing dramatically faster during incidents.

Additionally, if you are building APIs and want to document your health check endpoints properly, Swagger Docs provides solid guidance on standardizing health endpoint schemas. Documenting your probe endpoints helps future-you and any collaborators understand the contract.

For teams that coordinate multiple services or on-call schedules, an operations management platform for teams can centralize incident response workflows so nothing falls through the cracks when pods start dying at 2am.

Five Actionable Rules for Probe Configuration

Do you want to avoid the silent cascade failure that kills your service? Follow these rules before your next deployment.

Never check external dependencies in liveness probes. Only check that your process is alive and can respond to requests.
Always use a startup probe for apps that take more than 5 seconds to initialize. Set the threshold generously based on measured startup times.
Point readiness probes at a dedicated endpoint that checks database connectivity and critical upstream services.
Log probe endpoint hits at debug level, not info level. Kubernetes hits these endpoints constantly. Info-level logging floods your log budget.
Test probe behavior in staging by deliberately killing dependencies and watching what Kubernetes does. Do not find out in production.

Meanwhile, if your service handles payments or other sensitive workflows, consider protecting your brand and service name early. Markavo Trademark Registration helps indie developers secure their product names before scaling up. A service outage is bad. Losing your brand name is worse.

If you are building content around your developer tools or SaaS product, Contentbase can help you automate and scale content marketing without hiring a full team. More visibility means more users, which means probe configuration becomes even more critical.

The Monitoring Gap Most Solo Devs Have

Here is the honest reality. Most indie hackers running Kubernetes either have no probe configuration, or they copy-paste something from a tutorial without understanding the thresholds. Both approaches create fragile systems.

The memory spike pattern described in production post-mortems across the industry follows a predictable shape. Probe fails. Container restarts. Initialization costs memory. Memory limit hit. Probe fails again. It looks like a memory bug. It is a probe configuration bug.

TechCrunch has covered the rising complexity of cloud-native infrastructure for small teams. The tooling is powerful but the configuration surface area is enormous. Probes are just one sharp edge.

In contrast, a well-configured probe setup costs you maybe two hours of work upfront. It saves you hours of incident response later. That math is obvious. However, most developers skip it because the app seems to work without it. It works, until it does not.

What to Watch and Do Right Now

If you are running anything on Kubernetes today, open your deployment YAML files. Check whether you have all three probes configured. Check what endpoints they point to. Verify that your liveness probe does not call any external service.

If you are still on traditional VMs or serverless and considering Kubernetes, understand that probes are not optional configuration. They are the mechanism by which Kubernetes decides whether your service exists. Get them wrong and your infrastructure works against you.

For solo developers managing multiple microservices, a quick audit of your health check endpoints is worth scheduling this week. Use the kubectl commands listed above to simulate what happens when a probe fails in your current setup. You might be surprised by what you find.

This post contains affiliate links. If you make a purchase through these links, we may earn a commission at no additional cost to you.