Over the past few years, infrastructure as code (IaC) has evolved rapidly. From Terraform to Pulumi, from CloudFormation to CDK, developers and platform teams have explored a range of tools to manage cloud resources. Now, enter Crossplane—a Kubernetes-native control plane for managing infrastructure. But in 2025, is Crossplane a game-changer or just another tool in an already crowded field?

Here, we'll break down the key arguments, explore its unique advantages, and consider whether Crossplane might finally be the one tool that bridges the gap between application deployments and cloud infrastructure management.

The Promise of a Kubernetes-Native Approach

GitOps and Continuous Reconciliation

One of Crossplane's primary claims to fame is its embrace of a true GitOps model. Instead of running separate pipelines or juggling multiple toolsets, Crossplane enables you to treat infrastructure as Kubernetes resources. Changes committed to Git automatically trigger reconciliation loops inside the cluster. In theory, this means that both application code and infrastructure share the same pull-based delivery model—a dream for teams already harnessing tools like ArgoCD or Flux.

Pairing Crossplane with Argo or Flux provides unparalleled infrastructure topology monitoring and drift detection capabilities. This combination enables powerful continuous reconciliation that surpasses traditional manual and one-off deployments.

Everything Is a Kubernetes Resource

Crossplane's approach means that everything is defined as a Kubernetes resource. Whether you're provisioning an S3 bucket, a VPC, or even an entire cluster, you do it via YAML manifests. This integration simplifies workflows for teams deeply embedded in the Kubernetes ecosystem. It reduces the friction of switching contexts between multiple IaC tools and cloud-specific CLIs.

Resources as Developer-Facing APIs

Another touted benefit is that infrastructure becomes an API. Developers can request, modify, and manage resources without needing to interact directly with cumbersome cloud provider interfaces. Instead, platform teams can offer "compositions" or pre-defined templates, enabling a self-service model that accelerates development cycles.

The service catalog-like nature of Crossplane's infrastructure management provides significant value for large enterprises, particularly in scenarios where compliance and auditability requirements are paramount.

The Catch: Complexity, YAML, and Missing Features

The Weight of Kubernetes

While leveraging Kubernetes as a control plane can streamline certain workflows, it also means inheriting its complexity. For organizations that aren't already "Kubernetes-first," the additional overhead might seem counterproductive. If your team is comfortable with a dedicated Terraform workflow, adding Kubernetes as a dependency might feel like reinventing the wheel.

YAML: The Double-Edged Sword

There's no escaping it, YAML is everywhere in the Crossplane universe. For those who appreciate the elegance of higher-level languages (like TypeScript or Python) or the robust module ecosystem in Terraform, YAML's limited programming constructs—no native loops or conditionals—can feel clunky. Although there are various features (like generators, anchors, or embedded scripting) to improve its ergonomics, YAML remains a common complaint among users.

No State File, No Plan?

A conversial topic is was Crossplane's approach to state management. Unlike Terraform, which maintains a state file (a source of truth and an audit log), Crossplane's "state" is embedded in resource status. This method raises concerns about:

• Visibility: Without a clear "plan" phase, it can be challenging to predict the impact of changes before they're applied.
• Auditability: Teams accustomed to versioned state files may find Crossplane's approach less transparent.

Many engineers have expressed frustration about flying blind without being able to see a dry run output showing the expected impact of proposed changes. In highly regulated environments, this lack of an independent audit trail could be a deal-breaker.

Real-World Use Cases and Future Directions

Despite the criticisms, Crossplane finds its niche in scenarios where its strengths shine:

• Multi-Cloud and Hybrid Environments: When managing resources across AWS, GCP, and on-premises setups, Crossplane can offer a unified interface. Its cloud-agnostic resource definitions and composition functions let you standardize deployments in a way that traditional tools struggle to match.
• Internal Developer Platforms: For large enterprises, platform teams can expose a curated set of compliant, pre-configured infrastructure "building blocks" via Crossplane. Developers then deploy their applications alongside the necessary cloud services—all via Kubernetes manifests.
• Drift Detection and Automated Remediation: Continuous reconciliation means that any deviation from the declared state (intentional or accidental) is automatically corrected, reducing "configuration drift" over time.

Conclusion: Is Crossplane Worth the Hype?

Crossplane isn't a silver bullet, but it offers compelling benefits for organizations already committed to Kubernetes and GitOps. Its model of managing infrastructure as Kubernetes resources can simplify operations in multi-cloud environments and provide powerful self-service capabilities. However, its reliance on YAML, absence of traditional state management, and inherent complexity mean that it's not a one-size-fits-all solution.

For teams weighing their options, the decision to adopt Crossplane should be driven by your existing tooling, team expertise, and the scale at which you operate.

It's not about which tool has the most features—it's about the people your platform team is trying to serve.

In the end, Crossplane represents a bold step towards unifying the worlds of application and infrastructure deployment. Whether it will become the cornerstone of modern DevOps remains to be seen, but its growing community and innovative approach make it a technology worth watching.