It was built to manage infrastructure — and in doing so, it carries complexity and then hidden costs. And at Clever Cloud, our guiding principle is to empower developers productivity, security, and autonomy.
Since then, the context has changed. The market is evolving, our clients too, and we now have the technological maturity to address such a need … in our own way. Here’s why we took the time to create our own version of ETCD, and why Kubernetes is finally arriving at Clever Cloud.
Why we didn’t jump on Kubernetes earlier
In the past, we never saw Kubernetes as a key driver for simplification. It’s sometimes experienced as an additional layer of complexity, especially for teams who just want to deploy, scale, and secure their applications: focus on value creation without spending too much time on the rest.
But scaling up often creates complicated machinery. As a cloud provider, we have to deliver on a very large scale. Our orchestrator, developed and enriched through 15 years of production experience, enables this. By directly executing runtimes (about fifteen, including Node.JS, PHP, Rust, Scala, Docker, etc.), our orchestration goes further in fine-grained provisioning and auto-scaling, smarter updates, and better security.
For us, containerization is not the be-all and end-all. If a runtime exists, we prefer to ease how to use it, natively provide it: this allows us to control the security updates of the base image without relying on the application team’s goodwill. For any code that doesn’t match an existing runtime, we naturally offer deployment via Docker images. However, bear in mind that while we can update the image, we cannot patch or update the encapsulated code.
However, as we continue to grow, we’re meeting increasingly larger prospects who are using Kubernetes. The market demands Kubernetes. More and more customers want interoperability with their existing tools, fine-grained workload management, or simply a standard for their teams. We couldn’t ignore it.
The weakest link in Kubernetes: ETCD
Kubernetes is often called the “the cloud’s operating system”. But like every OS, it relies on a critical component: ETCD — a distributed key-value store meant to record the cluster’s global state. And that’s where problems begin.
ETCD can’t handle the load. Its architecture, designed for modest cases, sets a hard 8 GB technical limit. Performances drop as soon as you scale up, documentation is lacking, and project governance has been weakened by successive maintainer changes.
It’s no coincidence that Google, Microsoft and other hyperscalers have rewritten their own versions of ETCD — or that projects like k3s replaced it with PostgreSQL. It’s an operational nightmare when your job is to keep systems running. When each customer has their own Kubernetes cluster, it potentially means thousands of ETCD instances to manage, each with its quirks, backups, and varying performance. In short: a challenge for our teams
Rethinking ETCD from the ground up: Our In-House Stack
So we did what Clever Cloud does best: smart reinvention. Using Materia KV, our serverless key-value database built on FoundationDB, we implemented ETCD our way.
Specifically, we recreated the key compatibility APIs (KeyValue, Watch, Lease, Compaction…) by interfacing them with infrastructure we fully control, offering:
- A multi-tenant architecture, designed for scale. Since we use FoundationDB as the database, we can apply horizontal scaling. Usually, adding nodes to ETCD slows it down — but each node added in MateriaETCD allows us to host more clients without negative impact;
- Fine-grained management of transactions, permissions, quotas, and statistics;
- A coherent stack maintained by our teams.
The result: a logically ETCD-compatible database — fast, reliable, scalable — built on FoundationDB, and operated at Clever Cloud scale. No more fragile clusters or overwhelmed DBAs: everything is integrated, industrialized, and instrumentable.
More importantly, this solution offers exceptional resilience, directly inherited from FoundationDB. Thanks to continuous simulation in a distributed environment, we can validate every software release across thousands of simulated failure scenarios. It’s a rare level of robustness that enables us to anticipate edge cases and guarantee very high service availability — and therefore, yours. This approach gives us unprecedented confidence in our ability to manage thousands of Kubernetes clusters without falling into the trap of exponentially growing operational complexity.
Clever Cloud Managed Kubernetes: a sovereign, pragmatic approach
We’re not changing our vision: our PaaS remains the best solution for teams seeking maximum productivity and security with minimal effort. But we also understand that some organizations need Kubernetes for architectural, portability, or standardization reasons.
That’s why our managed Kubernetes enters private access phase today. If you’re a Clever Cloud customer and want to test it, you can contact us now to get it.
Our pledge? An integrated, secure, and mastered Kubernetes — built on a solid technical foundation. A Kubernetes that adheres to best practices — but without the flaws of its legacy components. A Kubernetes that finally lets you focus on your business.