Myth: Kubernetes makes things simpler.
Reality: It makes some things simpler at scale and many things more complex below it.
Kubernetes is brilliant at what it does. It also comes with a lot of moving parts. Here's how to tell whether you need it, or just want the conference sticker.
By Anvexis Stack Engineering8 min read
| If you have… | Consider |
|---|---|
| One or two apps, small team | VM + Docker Compose |
| Several web services, no platform team | Managed containers (Cloud Run, ECS, App Service) |
| Many services, autoscaling needs, platform engineers | Managed Kubernetes |
| Strict on-premise requirements at scale | Self-managed Kubernetes, carefully |
The project describes itself as a portable, extensible platform for managing containerized workloads with declarative configuration and automationSource [1]. In practice, that means service discovery and load balancing, automated rollouts and rollbacks, self-healing when containers fail, horizontal scaling, and built-in handling of secrets and configurationSource [1]. For organizations running many services with uneven traffic, those are significant benefits.
It also standardizes operations across teams. When every service is deployed the same way, platform engineers can provide shared tooling for logging, monitoring, and security once, instead of rebuilding it for each application. That standardization is often the real reason large companies adopt it.
Here's the part that surprises teams. The Kubernetes documentation states plainly that it is not a traditional, all-inclusive platform as a service, and that it doesn't provide application-level services such as message buses, databases, caches, or cluster storage systems as built-in featuresSource [1]. You still choose, run, back up, and upgrade all of those.
So a cluster doesn't remove the database question. It adds a layer underneath it. For most business applications, the database is the part that actually needs care, and putting it on Kubernetes before the team knows the platform well is a reliable way to have a bad week.
Myth: Kubernetes makes things simpler.
Reality: It makes some things simpler at scale and many things more complex below it.
Myth: We need it to scale.
Reality: Most apps scale fine on a few well-sized instances behind a load balancer.
Myth: It's free because it's open source.
Reality: The software is free. The expertise, monitoring, and upgrades are not.
Myth: Managed Kubernetes means someone else runs it.
Reality: The provider runs the control plane. Your workloads, upgrades, and incidents are still yours.
The price is complexity. A cluster has its own networking, storage, security model, upgrade cycle, and failure modes. Someone has to understand ingress controllers, persistent volumes, resource limits, and why a pod is stuck in a crash loop at two in the morning.
The upgrade cycle deserves its own line in the budget. The Kubernetes project maintains release branches only for the three most recent minor releases, and each release gets roughly a year of patch supportSource [2]. That means a cluster needs a version upgrade about once a year, every year, along with the add-ons and manifests that depend on it. Managed services such as EKS, GKE, and AKS make the mechanics easier, but someone still has to test your workloads on the new version.
Ask who will be paged when the cluster misbehaves, and whether they know how to fix it. If the answer is “nobody” or “the one person who set it up”, pick something simpler and revisit when the scale demands it.
A platform your team can operate confidently at three in the morning beats a more sophisticated one that only makes sense on an architecture diagram. Operational confidence is a feature.
A well-configured virtual machine running Docker Compose can serve a business application reliably for years, especially with automated deployments, tested backups, and monitoring. It's easy to understand, easy to debug, and easy to hand over.
Many Odoo deployments fit comfortably here: one application, one database, predictable load. Moving them to Kubernetes adds operational cost without solving a problem they actually have. If an Odoo instance is slow, the answer is almost always in the database and the worker configuration, which we cover in the architecture behind high-performance Odoo.
Between a single server and a full cluster sits a set of managed platforms: Cloud Run, AWS App Runner and ECS, Azure Container Apps, and similar services. They run your containers, scale them, and roll out new versions without exposing cluster internals. For many web applications, they offer most of what teams hoped to get from Kubernetes at a fraction of the operational effort.
Containerizing your applications is the valuable first step regardless. Good images, built in CI and configured through environment variables, run on any of these options, so moving later is far easier. Our Docker and Kubernetes work usually starts here, whatever the destination.
Consider Kubernetes when you run many services that need to be deployed independently, when traffic varies enough that automatic scaling saves real money, when several teams need a shared platform, or when you already have engineers who know how to run it.
Even then, start with a managed cluster, keep stateful services such as databases outside it until you have the experience, and adopt features gradually. The goal is a platform your team can operate confidently, not the most sophisticated diagram.
Autoscaling is the benefit people quote most, and it's real, but only for workloads whose traffic actually swings. A business application used steadily from nine to six doesn't gain much from scaling pods up and down; the cluster's own fixed costs, such as nodes kept running for headroom, the control plane, and monitoring, can outweigh the savings.
Before choosing a platform for its scaling, look at your traffic over a few months. If peaks are predictable, such as month-end or a seasonal sale, scheduling extra capacity on a simple platform is often cheaper and easier to reason about than a cluster tuned for elasticity it rarely needs.
A default cluster is not a secure cluster. Role-based access control, network policies between services, image provenance, secrets handling, and regular patching of nodes all need deliberate configuration and ongoing attention. Misconfiguration, not exotic attacks, is the usual way clusters get into trouble.
Simpler platforms have fewer knobs to get wrong. If your team is small, that's not a limitation; it's a security feature. Whatever you choose, keep secrets out of images and code, and apply updates on a schedule rather than when something breaks.
| Aspect | VM + Compose | Managed containers | Managed Kubernetes |
|---|---|---|---|
| Best for | One or two apps | Several stateless services | Many services and teams |
| Autoscaling | Manual | Built in | Built in, highly configurable |
| Zero-downtime deploys | Possible with care | Built in | Built in |
| Skills needed | Linux basics | Containers, one cloud | Containers plus Kubernetes operations |
| Yearly upgrade work | OS and Docker | Mostly handled by provider | Cluster version plus add-ons |
Start with one stateless service on a managed cluster, with monitoring, logging, and deployment automation in place before more services follow. Keep databases on managed services until the team is comfortable. Write runbooks as you learn, and practise upgrades on a non-production cluster first.
Set resource requests and limits from day one, because a cluster with none behaves unpredictably under load. Decide on a small set of supported patterns, such as one ingress controller and one way to manage secrets, and resist adding tools until there's a clear need.
Whatever you choose, the same essentials apply: automated builds and deployments, backups that are tested, monitoring that alerts a person, secrets kept out of code, and security updates applied regularly. A simple platform with these in place is far more reliable than a sophisticated one without them.
Before debating platforms, check that these basics are solid. Very often, improving them delivers the reliability teams were hoping Kubernetes would bring. That's the starting point of our CI/CD automation work.
The right answer today may not be the right answer in two years. Note the signals that would change your mind, such as the number of services, the size of the platform team, or the cost of idle capacity, and review them once a year. Because the applications are containerized, moving up a level when the time comes is a project, not a rewrite.
Moving down is allowed too. Teams sometimes adopt a cluster for a growth plan that never arrived, and carry its upgrade and on-call cost for years. If a review shows a handful of steady services and nobody who enjoys running the platform, migrating to managed containers or a well-run VM is a perfectly respectable engineering decision. The goal was always reliable software, not a particular logo on the architecture diagram.
Written by Anvexis Stack
We build Odoo, AI, web, and cloud systems for growing companies, and we write about the patterns we use. This is engineering guidance, not a product guarantee: check vendor details for your version before you decide. Last reviewed .
Docker & Kubernetes
Containerize Odoo and services with Docker, then orchestrate with Kubernetes when it's warranted: health checks, autoscaling, and rollouts.
DevOpsCloud architecture
Cloud architecture on AWS, GCP, Azure, and bare metal: landing zones, networking, Terraform, cost control, and hybrid setups.
InsightsHigh-performance Odoo
How large Odoo deployments stay fast: worker processes, load balancing, PostgreSQL tuning, replicas, caching, and long-polling.
Next step
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.