Kubernetes: The Anti-Pattern
Why small teams should avoid Kubernetes overhead.
TL;DR:
- Kubernetes can leave small teams maintaining a platform instead of building for customers.
- Choose managed services that meet your workload’s needs, and revisit Kubernetes when simpler options impose a concrete constraint.
Kubernetes is often pitched as a way to make infrastructure someone else’s problem. For small teams, it frequently does the opposite: infrastructure becomes a permanent product they have to maintain.
Kubernetes isn’t bad software. Its strengths, including extensible orchestration, standardized deployment primitives, and fine-grained control, solve problems many young companies don’t yet have. The costs arrive immediately.
For a small engineering team, the better question isn’t “Can we run Kubernetes?” It’s “What customer-facing work will we stop doing to run it well?”
The abstraction that becomes another application
Kubernetes abstracts machines, not operations. Someone still owns resource sizing, deployment safety, network policy, identity, secrets, observability, and recovery. Managed Kubernetes removes much of the control-plane burden, but it doesn’t automatically remove responsibility for workloads and supporting components inside the cluster.
A simple web service can pick up a surprisingly long dependency chain: container registry, cluster, ingress controller, certificate automation, DNS integration, metrics pipeline, deployment tooling, and perhaps a service mesh. Each component may make sense on its own. Together, they become a second application, with your developers as its users.
That application needs upgrades, compatibility checks, permissions, documentation, and incident response. Failures can cross layers. A pending pod might point to insufficient capacity, a scheduling constraint, a storage issue, or an admission policy. Figuring out which requires knowledge unrelated to the customer’s problem.
Consider an illustrative team of six engineers running an API, background workers, and a relational database. If one engineer spends a day each week maintaining the platform, the visible labor cost looks manageable. But that calculation leaves out interruptions, review overhead, and the risk of concentrating operational knowledge in one person.
The real cost is lost organizational attention, something small teams have little of to spare.
Buy the operating model, not just the compute
The strongest alternatives don’t just host containers. They give you a narrower set of operational responsibilities.
A managed application platform can accept source code or an image and handle routing, TLS, health checks, deployment revisions, and basic scaling. Developers get an application-level interface instead of having to assemble those capabilities themselves.
Serverless container services offer a similar bargain with different constraints. They suit request-driven services and some asynchronous workloads, particularly when demand is uneven. Functions can work well for short, event-triggered tasks. Neither fits every workload: execution limits, concurrency behavior, cold starts, and networking requirements can shape the architecture.
For predictable workloads, a straightforward virtual machine or managed instance group may also beat a cluster. Simplicity doesn’t require serverless. It means reducing the number of interacting systems your team needs to understand.
Start the purchasing decision with workload behavior:
- Does the service need persistent local state, or can state live in managed storage?
- Are tasks short-lived, or do they require long-running processes?
- Must capacity respond instantly, or is modest scaling latency acceptable?
- Does the platform support private networking, rollback, and useful diagnostics without custom glue?
Keep databases outside the orchestration debate where practical. A managed database with tested recovery procedures usually does more for a small team’s resilience than sophisticated scheduling around a self-operated database.
You’re not aiming for zero operations. You want a clear boundary around the operations that remain yours.
Portability is valuable; premature portability is expensive
Kubernetes advocates rightly point to a common deployment interface across infrastructure providers. But portable manifests aren’t the same as a portable system.
Applications still depend on provider-specific identity, load balancers, storage classes, databases, networking, and observability. Moving a cluster-based workload can require substantial redesign despite the familiar YAML.
Managed platforms have their own lock-in. Compare the probable cost of leaving later with the certain cost of maintaining flexibility now.
A small team can keep meaningful exit options without adopting Kubernetes. Package services as standard container images, and keep configuration separate from application code. Prefer conventional database interfaces where appropriate. Automate provisioning and document data export and restoration. These steps don’t guarantee an easy migration, but they preserve more practical options than an unused multi-cloud strategy.
There are legitimate reasons to choose Kubernetes early: specialized scheduling, GPU workloads, complex networking, strict deployment requirements, or an existing team with proven platform expertise. Even then, the business case should name the requirement that simpler services can’t satisfy.
“Eventually we might need it” isn’t a requirement. Neither is familiarity from a previous employer with a much larger infrastructure organization.
Adoption makes sense when enough workloads and teams share the platform burden, or when the required control creates measurable business value.
Bottom line
For small teams, Kubernetes is often an anti-pattern because it prioritizes infrastructure flexibility before the business can justify the complexity.
Choose the highest-level managed service that meets the workload’s real requirements. Look at its limits, failure behavior, and exit path, not just its introductory price. Track operational interruptions alongside the cloud bill.
Revisit Kubernetes when simpler platforms impose a concrete constraint, not when the architecture feels insufficiently ambitious. The best infrastructure lets a small team keep its promises to customers.