
Kubernetes is everywhere. Conference talks assume it, job postings list it, and many new tools ship with a Helm chart. CNCF's January 2026 survey found that 82% of container users now run Kubernetes in production, up from 66% in 2023.
That number is real, but it answers a different question from the one on your mind. The survey covers container users, so it measures how many teams that already chose containers run Kubernetes, not how many teams need it. It's also run by the foundation that hosts the project, so read it as a picture of the ecosystem rather than a neutral census of every team. It tells you Kubernetes is popular, not whether your team, with your workloads, should pay its costs. CNCF's own 2021 survey found that adoption was far higher in large organizations than in small ones.
So here's my honest answer up front, and it's an opinion rather than a law: most teams don't need Kubernetes on day one, and plenty never will. But some teams clearly do, and the skill is knowing which group you're in.
This post covers what Kubernetes actually gives you, what it costs, what to use instead, and a simple way to decide.
What Kubernetes actually gives you
The benefits are real, and at scale they're hard to replicate by hand:
Self-healing and desired state. You declare what should be running, and Kubernetes keeps reality matching it, restarting or rescheduling failed workloads.
Scheduling and bin packing. Workloads are placed efficiently across a pool of machines.
Rolling updates and rollbacks built into the platform.
Service discovery, load balancing, and autoscaling under one API.
Extensibility. Custom resources and operators let you manage databases, certificates, and more declaratively.
A common API across clouds and on-prem, with a huge ecosystem and talent pool.
If you have dozens of services, several teams, or demanding workloads, these features start to pay for themselves.
What it costs
The price isn't the cluster bill. It's the surface area you take on:
Operational complexity. Networking, ingress, storage, RBAC, secrets, and policies are all yours to design and understand.
Upgrades never end. New minor versions arrive about three times a year, and each one gets roughly a year of patch support, so keeping current is a permanent chore.
The add-on tax. A usable cluster typically needs an ingress controller, certificate management, DNS automation, metrics, logging, and a GitOps tool. Each one is another thing to install, secure, and upgrade.
Cognitive load on developers. Manifests, health probes, resource requests and limits, and Helm or Kustomize become part of everyone's job.
Harder debugging. There are more layers between your code and the symptom.
Managed services such as EKS, GKE, and AKS take the control plane off your plate, and modes like GKE Autopilot and EKS Auto Mode go further by managing nodes too. EKS Auto Mode also builds in capabilities such as autoscaling, load balancing, DNS, and block storage that you would otherwise install and maintain yourself. That meaningfully reduces toil, but you still own the learning curve, the rest of the ecosystem (observability, GitOps, policy, certificates), and the configuration of your own workloads.
Signs you probably don't need it (yet)
You run one application or a handful of services.
Your traffic is predictable and modest.
Your team is small and nobody owns infrastructure full time.
Your real problems are slow CI, risky releases, or missing monitoring. Kubernetes fixes none of those.
The main reason is "everyone else is doing it" or a wish to build experience for your résumé.
What to use instead
Many teams are better served by something simpler:
Option | Good fit when | Trade-off |
|---|---|---|
One or two servers with Docker Compose and a load balancer | Small apps and early-stage products | You handle patching, scaling, and failover yourself |
A PaaS (Heroku, Render, Fly.io, and similar) | You want to push code and move on | Less control, and costs can climb with scale |
Serverless containers (Google Cloud Run, Azure Container Apps) | HTTP services and jobs with spiky or low traffic | Platform limits and less flexibility for unusual workloads |
AWS ECS with Fargate | AWS-centric teams that want containers without running clusters | AWS-specific, with a smaller ecosystem than Kubernetes |
HashiCorp Nomad | You want an orchestrator simpler than Kubernetes | Smaller ecosystem and hiring pool |
For a small app, a setup like this is a perfectly respectable production deployment:
services:
web:
image: registry.example.com/app:1.4.0
restart: unless-stopped
ports:
- "80:3000"
env_file: .env
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
interval: 30s
timeout: 5s
retries: 3Two caveats on that snippet. The health check assumes curl exists in your image, which slim images often lack. And plain Docker Compose will mark a container unhealthy but won't restart it for you, so pair the check with your load balancer or monitoring.
Run it on two hosts behind a load balancer and you've removed the most obvious single point of failure, the app server, without introducing a cluster. Your database and the load balancer itself still need their own redundancy plan.
Signs you probably do need it
You run many services owned by multiple teams and want a consistent, self-service platform.
You need to run across several clouds or on-premises, perhaps because of data residency or regulatory requirements.
Your workloads need custom controllers or operators, complex stateful orchestration, or GPU scheduling.
Your scale and utilization are high enough that efficient bin packing saves real money.
You've outgrown the limits of simpler platforms and can name the specific limit you hit.
You have, or are willing to fund, people who know how to run it well.
What real teams report
Public write-ups are worth reading because they show the trade-off in practice. Here are three, covering both directions:
A workload mismatch (Gitpod). After about six years of running cloud development environments on Kubernetes for 1.5 million users, Gitpod explained why it was moving off it. Its argument was specific to its workload: development environments are stateful, interactive, and unpredictable in resource use, which clashed with what Kubernetes does best. The team has said Kubernetes is still a fine choice for ordinary application workloads, so this is a story about fit, not a verdict on the platform.
A small team choosing simplicity (In The Pocket). The cloud team at In The Pocket described moving its services from Kubernetes to AWS ECS Fargate over about six months, one service at a time. Their reasons were the day-to-day cognitive overhead, the amount of setup and configuration, the extra complexity for new team members, and tighter integration with other AWS services.
Outgrowing a simpler platform (Rainforest QA). In 2018, Rainforest QA concluded it had outgrown Heroku, which had let it scale without a large operations team. It cited database size limits, an inability to put Postgres in private networks, and cost, and chose managed Kubernetes on Google Cloud, partly for needs like autoscaling on custom metrics. Because its ops team was small, it picked a managed offering over running its own cluster.
The pattern is worth noticing. The team that adopted Kubernetes could name the specific limits it had hit, and it chose the option that kept the operational burden small. The teams that left cited complexity or a poor match with their workload.
Two caveats apply. These are self-reported accounts, and teams tend to write about dramatic moves, so the many teams quietly happy with their choice, whichever it is, are underrepresented.
The strongest case for "just start with Kubernetes"
It deserves a fair hearing. Supporters argue that:
Kubernetes skills transfer between employers and clouds.
Starting on it avoids a painful migration later.
Managed offerings are far easier to run than they used to be.
Its ecosystem of tools is unmatched.
These points have merit, especially if your team already knows Kubernetes well, because then its cost to you is much lower. But migrations are manageable when you've kept your apps containerized, configured through environment variables, and equipped with health endpoints. By the time you outgrow a simpler platform, you'll also know your real requirements instead of guessing at them.
What moving to Kubernetes later actually involves
"Migrate later" only works if you've made it cheap. The good news is that the groundwork is mostly good container hygiene, which pays off on any platform:
Keep services stateless, and push state into managed databases, caches, and object storage.
Configure through environment variables and a secrets store, not files baked into images.
Log to standard output so any platform can collect your logs.
Expose health endpoints and shut down gracefully when told to stop. Kubernetes and most other platforms rely on both.
When the time comes, migrate the way In The Pocket did in the other direction: one service at a time. Stand up the new platform beside the old one, move a low-risk service first, shift traffic gradually with weighted routing at your load balancer or DNS, and keep the old deployment available for rollback until the new one has proven itself.
Expect real work in the parts that are new to your team: manifests or Helm charts, ingress, resource requests and limits, probes, secrets handling, and the changes to observability and your deployment pipeline. Budget time for learning rather than treating it as a simple lift and shift.
Questions to ask before adopting it
What specific problem do we have that simpler options can't solve?
Who owns upgrades, security patches, and on-call for the cluster?
Do we have the skills, or a realistic plan to build or hire them?
Have we honestly evaluated managed or serverless container platforms?
Are the fundamentals in place: CI/CD, observability, infrastructure as code, and tested backups?
Have we counted the cost in engineering hours, not just the cloud bill?
If several of these draw blank stares, that's your answer for now.
A pragmatic path
Containerize and automate first. Good images, a solid pipeline, and health checks make every later platform choice easier.
Start on the simplest platform that meets today's needs, not next year's imagined ones.
Write down your triggers. Make them specific enough to check. Rainforest QA's named limits, such as database size caps, a need for private networking, and autoscaling on custom metrics, show what that looks like. Yours might be "we run more than N independently deployed services," "two teams are building their own deployment tooling," or "our current platform can't meet a requirement we can name." Choose your own N, since the point is tying the decision to evidence, and revisit the list every few months.
If you adopt Kubernetes, do it carefully. Use a managed service, keep the add-on list short, automate upgrades, and manage configuration through GitOps.
Final thoughts
Kubernetes is excellent technology that solves real problems at real scale. The mistake isn't using it. The mistake is adopting it before you have the problems it solves, and then spending your best engineers' time on the platform instead of the product.
Pick the simplest platform whose limits you won't hit this year, and write down the signals that mean it's time to move. When those signals appear, you'll know exactly what you need Kubernetes for.
A note on sources: this post draws on CNCF survey data, the official Kubernetes and cloud provider documentation, and public write-ups from teams that moved in each direction, linked where they're discussed.
Have you moved to or away from Kubernetes? What was the deciding factor? Share your story in the comments.
Comments(0)
Join the discussion by logging into your account.
No comments yet. Be the first to comment!