Do you practice DevOps or Cloud today? You’ve surely already experienced this frustrating situation: you’re developing a new feature or a critical application, but everything stops because you need to create a Jira ticket to provision a database, an S3 bucket, or any other cloud service. Welcome to the world of TicketOps. This process, too widespread in companies, creates bottlenecks, silos, and breaks the agility IT and DevOps teams have spent years building.
Let’s be clear: the famous principle “you build it, you run it” too often becomes “you build it, someone else queues it, and maybe one day you can run it.” Result: wasted time, frustrated developers, and slowed innovation.
Why Terraform is not suited for Platform Engineering
Terraform is popular, and it works well for managing resources occasionally. But Terraform is not ideal for Platform Engineering. Here’s why:
- Manual cycle: A terraform apply is required for every change. Not great for dynamic, evolving resources.
- No native API: Impossible to easily expose your infrastructure as self-service through a simple API.
- No continuous reconciliation: Terraform doesn’t automatically adjust your infrastructure to match the desired state.
In short, for a “platform-as-a-service,” Terraform quickly reaches its limits.
Kubernetes + KRM + CRDs: the new self-service model
Kubernetes is no longer just a container orchestrator. Today, Kubernetes is a true universal control plane for your entire infrastructure. How? With the Kubernetes Resource Model (KRM) and Custom Resource Definitions (CRDs). CRD (Custom Resource Definitions).
Imagine this:
- Need a database? Apply a YAML.
- Need a Cloud Storage bucket? Another YAML.
- Want a Redis cache? That same YAML again.
This is pure self-service, with no tickets, thanks to Kubernetes and projects such as Crossplane, AWS Controllers for Kubernetes (ACK) ou Google Config Connector.
During his talk at the Control Plane Day with Crossplane 2023, Kelsey Hightower, Developer Advocate at Google and a prominent figure in the Cloud Native ecosystem, clearly stated:
"Terraform is not suited for building control planes similar to those of major public cloud providers."
This statement carries weight, as Kelsey is widely recognized for his expertise and influence in the Kubernetes and Cloud Native community, notably for his conferences, live demos, and contributions that have guided the adoption of modern infrastructure best practices.
Level up: Expose everything via REST, gRPC, and SDKs
Looking at this architecture, you immediately see the goal: give teams autonomy without losing control. Kubernetes acts as a central control plane, based on the KRM (Kubernetes Resource Model). Product, DevOps, and development teams can provision the services they need themselves through a single API, exposed via REST, gRPC, or even WebSocket.
This API is not just a gadget. It becomes a standard entry point, usable with client libraries (Go, Python, JavaScript, Java), CLI tools, or internal platforms like Backstage. The result: teams no longer waste time with tickets, and delivery cycles accelerate.
In the background, the platform continuously reconciles resources with your cloud providers and key tools (Google Cloud, GitLab, Kubernetes, Vault, Okta…). While your teams consume these services in self-service mode, your Platform Engineering, SRE, and DevSecOps teams can enforce company-wide best practices, security rules, and reliability standards.
This model allows you to industrialize the cloud at scale without friction. You maintain governance, and teams gain speed. It’s the best of both worlds.
Even better, you can expose your services as a first-class API. With your CRDs, you can automatically generate protobuf files, then easily expose a REST or gRPC API and even provide SDKs for every language your developers use.
Your developers won’t even need to write YAML anymore. They will use your platform API directly. The modern developer’s dream becomes reality:
- Zero tickets
- Instant provisioning
- Transparent GitOps integration
The numbers speak for themselves
Here are concrete KPIs observed in organizations that made the leap:
- 🚀 +50% developer productivity
- 🕒 -36% lead time between commit and production
- 🧘 +40% improvement in software quality
- 📈 75% of large enterprises will adopt this model by the end of 2025 (according to Gartner)
Goodbye TicketOps, Hello Self-Service
Gone are the days of endless Jira tickets for simple provisioning. Adopt Kubernetes as the foundation of your Platform Engineering with KRM and CRDs to offer your teams a truly self-service experience.
Your infrastructure will finally be agile, scalable, API-first, and your developers will thank you (maybe even with cookies). 🍪
So, are you ready to leave Terraform behind and dive into the future with Kubernetes? You won’t regret it! 🚀
Conclusion: how Edixos can support you
At Edixos we know that a cloud platform is not just a stack of tools: it must be designed to last, evolve, and meet the specific needs of each organization. Our expertise goes far beyond simply deploying Kubernetes clusters:
- We write custom Kubernetes controllers capable of automating your business processes and specific needs.
- We integrate powerful composition solutions such as Crossplane or Kro which allow you to transform Kubernetes into a true multi-cloud provisioning engine.
- We work with existing controllers like Config Connector (KCC), which natively expose major cloud providers’ services via Kubernetes CRDs.
- We know how to build complete, API-first platforms, exposing your services via REST, gRPC, and multi-language SDKs, to unify access and accelerate adoption by your teams.
What we offer is unique know-how to industrialize your cloud platforms: governance, security, and self-service at scale. If your ambition is to build a robust platform that aligns innovation, agility, and control, we have the technical building blocks and experience to make it happen.
Why Terraform is not suited for Platform Engineering