Kubernetes is powerful, well designed and the industry standard for running containers. I still don't like it. What bothers me is what it demands from the team that has to run it: a lot of knowledge, constant maintenance and a cost that never shows up on the architecture diagram.
Every time Amazon EKS comes up in a design discussion, it's justified with the same two arguments: we need it to be portable, and it's the industry standard. Both are partly right. In this article I explain why neither convinces me on its own, and when I do choose Kubernetes.
Note: It's a personal opinion, based on my experience as an architect, and it doesn't apply to every context: if yours is different, your conclusion may reasonably be different too.
I'll go in this order: what Kubernetes demands, the two arguments used to justify it (portability and being the industry standard) and when I do choose it.
The basics of Kubernetes and Amazon EKS are in Part 1 of my series on my blog, and the comparison between AWS Lambda, Amazon ECS with AWS Fargate and EKS is in Part 2. You don't need either of them to follow this article.
What Kubernetes demands
From what I've seen as an architect, running the application containers is the easy part. The difficulty is everything around them. Kubernetes takes a lot of knowledge to understand, and then it has to be maintained: upgrades, add-ons, nodes, scaling, isolation between teams and shutting down environments nobody uses.
Even deployment usually needs its own piece. On Kubernetes the usual answer is a GitOps tool such as Argo CD or Flux, which continuously compares what Git says with what is actually running in the cluster and detects the differences, manual changes included, and can correct them automatically if configured to.
It's good practice, but it's also another component to install, upgrade and secure. With Amazon ECS, a pipeline and infrastructure as code are usually enough.
Upgrading isn't optional
EKS upgrades the control plane automatically when extended support ends, at a time you don't choose.
Kubernetes ships a minor version roughly every four months and EKS follows that pace. According to the EKS versions documentation, each version gets 14 months of standard support followed by 12 months of extended support. According to the pricing page, extended support raises the per-cluster fee from $0.10 to $0.60 per hour.
The date is known in advance (it appears in the version calendar and AWS sends a notice through AWS Health at least 60 days ahead), but not the exact moment, and add-ons and nodes remain yours. It's better to upgrade earlier, at your own pace.
Watch out: Each upgrade is a small project: checking that add-ons, controllers and CRDs (the Kubernetes API extensions installed in the cluster) support the new version, upgrading nodes or AMIs, testing deployments and having someone on call in case something goes wrong.
The difference looks small per hour, but it adds up. Figures per cluster, at 730 hours per month and 8,760 per year:
| Standard support ($0.10/h) | Extended support ($0.60/h) | Difference | |
|---|---|---|---|
| Per month | $73 | $438 | +$365 |
| Per year | $876 | $5,256 | +$4,380 |
| 3 environments (dev, staging and prod), per year | $2,628 | $15,768 | +$13,140 |
Note: This is only the control plane fee of each cluster. It doesn't include nodes, storage, traffic or any other cost, and the rates are the ones published on the EKS pricing page at the time of writing.
Tip: You can avoid that charge by configuring the cluster so that EKS upgrades it when standard support ends, in exchange for upgrading earlier.
Even so, the fee is the least of it. The real cost is the engineering time of each upgrade and the on-call duty of whoever runs it and watches the result. To stay in standard support you have to move up a version at least once every 14 months, on every cluster in every environment, and that should be budgeted from the start.
With Amazon ECS on AWS Fargate that work doesn't exist in that form: there is no orchestrator version calendar and there are no cluster add-ons to maintain. There is still work (images, dependencies, configuration), but not a version cycle of the orchestrator itself.
What about EKS Auto Mode?
EKS Auto Mode is EKS where AWS also manages the nodes and the core cluster components. It removes a lot of that work, but it doesn't remove the Kubernetes version calendar, your own add-ons and controllers, observability, RBAC, or the knowledge the team needs to diagnose a problem. Part 1 details what AWS manages in each option.
It also has a cost. Auto Mode charges a management fee per Amazon EC2 instance it launches, on top of the instance price and the cluster fee. For an m7i.large in US East (N. Virginia), as of November 2026, the fee is $0.0121 per hour, about 12% of the instance's $0.1008 On-Demand price:
| Auto Mode management fee ($0.0121/h) | 1 node | 10 nodes | 30 nodes |
|---|---|---|---|
| Per month (730 h) | $8.83 | $88.30 | $264.90 |
| Per year (8,760 h) | $106 | $1,060 | $3,180 |
The fee grows with the number of nodes.
Watch out: It applies to every purchase option, Spot and Savings Plans included, and it is a fixed amount per instance type, so it weighs more on discounted capacity.
We need it to be portable
Portability tends to show up in the default requirements list of every new architecture: scalable, secure, highly available and portable. The argument is almost always the same, in case we ever have to switch providers, and it is almost always translated into Kubernetes without specifying which risk it covers, how likely that risk is or on what timeframe.
That's a fair point. The Kubernetes API is the same on AWS, on other clouds and on-premises. That part of portability is real; the problem is everything that sits outside that API.
Covering that risk in advance with Kubernetes has a certain and continuous cost: platform complexity, permanent maintenance, and knowledge the team has to acquire and keep. In return it offers a hypothetical benefit that, in the projects I have seen, has rarely materialized. The requirement is legitimate, but it should be specified and costed like any other.
Three reasons it isn't enough:
- New developments in isolated accounts with a handful of microservices don't justify EKS for portability. There is no existing platform to build on, so the whole cost of building and maintaining one falls on the project.
- What is portable are the applications, not the platform. With standard images they run the same on Amazon ECS, on EKS or on your own server, while the platform has to be rebuilt when you switch providers, Kubernetes included. Part 2 details what doesn't travel with the cluster.
- A cloud-native development is already coupled to the chosen cloud. The coupling sits in identity (AWS IAM), queues (Amazon SQS), databases (Amazon DynamoDB, Amazon RDS), managed services in general and infrastructure as code, and Kubernetes doesn't remove it.
Isn't ECS AWS lock-in?
Yes: the ECS task definition and service are AWS-specific. But that is the cheapest part to migrate, because the container images are standard. The expensive coupling (IAM, data, managed services) is the same on EKS, through IAM roles for service accounts (IRSA) or EKS Pod Identity, the AWS Load Balancer Controller and the VPC CNI. Choosing EKS doesn't remove the lock-in, it only moves where it lives.
Where portability does pay off
The portability that actually pays off lives in layers that don't require Kubernetes:
- infrastructure as code, so the environment can be recreated;
- clear API contracts, so consumers don't depend on the provider;
- exportable data in open formats;
- business logic separated from provider integration, so changing a queue or a database touches one layer and not the whole codebase.
How I evaluate a portability requirement
These are the questions I ask before accepting it:
- Which concrete risk does it cover (regulatory, contractual, strategic) and who raised it?
- How likely is it, and on what timeframe? Is there a decision or a date, or is it a generic precaution?
- What would it cost to migrate the parts Kubernetes doesn't cover (identity, data, managed services, infrastructure as code)?
Tip: If, after answering them, the requirement still has a concrete risk and timeframe, EKS is a reasonable answer. If not, it's a preference, and a preference doesn't justify a whole platform.
It's the industry standard
It is, and that has real value: there's documentation, tooling and a huge community, and what you learn applies to any provider.
But being the standard doesn't make it cheap. Running a cluster in production is not the same as deploying to one, and it still demands that knowledge, the maintenance I described above and its price.
So it depends on where you start. If the organization already has that knowledge and a cluster running, the argument carries weight and Kubernetes makes sense.
Watch out: If not, the project has to build that capability on top of the application.
When Kubernetes is the right decision
In some contexts Kubernetes is the right decision. Part 2 develops the concrete requirements:
- Large customers with a cluster already running and many applications. The platform, the team and the processes already exist, so one more workload barely changes the cost.
- A regulatory requirement. A regulation that requires you to be able to run outside a single provider.
- A multicloud strategy that will actually happen. A real plan, not a future possibility.
- On-premises workloads. AWS offers EKS Hybrid Nodes and EKS Anywhere for this case.
Note: I haven't used either of them in a real project, and I'd be interested in hearing from anyone who has.
Summary
| Argument | What is true about it | What it doesn't cover |
|---|---|---|
| Portability | The Kubernetes API is the same everywhere | Identity, data, managed services and infrastructure as code remain coupled |
| It's the industry standard | Documentation, tooling and community | Running a cluster takes knowledge, maintenance and budget |
Conclusion
I choose Kubernetes when a concrete requirement justifies it or when the organization already has the platform and the team. Otherwise I look for the solution that covers the same needs with less to maintain.
Tip: Before adding Kubernetes to an architecture, I ask which requirement needs it and who will maintain it two years from now.
Top comments (0)