Why Crossplane Is so Exciting

I’ve just joined Upbound as a Product Manager and can’t be more excited to be part of this journey. I truly believe that Crossplane offers some unique capabilities to make teams more innovative and productive by leveraging cloud services. For Crossplane experts, this is no news. For folks who are new to Crossplane, I hope this post adds a perspective.

If you build software today, you can choose from a sheer endless amount of cloud services. Just AWS alone keeps adding new services to their 200+ services every month, and the other cloud providers are keeping up. If you want to be competitive with your software development, you need to leverage these services. Setting up and managing your message queue doesn’t add any value to your product. Choosing a mediocre database that is not the best tool for the job makes your team slower. – You need to make sure your team can leverage the advantages the current cloud era provides!

But how do you approach this? Hand out cloud provider accounts to developers and let them pick what they want? While this sounds fun, it’s unrealistic for almost all software organizations and not desirable as developers will get overwhelmed with options. The answer to this challenge is to provide a subset of these services catered to your specific needs. Typically, this is done collaboratively in a platform team and manifests itself in a developer platform.

Developer Platforms Done Right

“Developer productivity platforms are increasingly recognized as a way to manage the cognitive load of engineering teams and decrease time to market for new features,” says Thoughtworks. Crossplane was purpose-built for building platforms and has a few advantages over other approaches. Here are four things that I think are particularly important and Crossplane got right:

1. A Developer-Friendly API

The first thing to get right is the API. Platform builders need a way to put guardrails in place and provide an API that developers can easily consume. As Crossplane builds upon Kubernetes, it’s no surprise that a developer creates a resource to request a particular service. For example, to provision a 20 GB Postgres instance that a platform team has defined, a developer would do a simple kubectl apply on:

apiVersion: database.example.org/v1alpha1
kind: PostgreSQLInstance
  name: my-db
  namespace: default
    storageGB: 20
      provider: aws
      environment: production
    name: db-conn

For Kubernetes developers, this is straightforward. And this has the added benefit that we fit seamlessly into the enormous Kubernetes tooling ecosystem. Especially in the current en vogue GitOps movement, which makes this also accessible to Non-Kubernetes developers.

2: Powerful and Flexible With Compositions

The implementation behind this API can be rather complex and may involve setting up the right cloud provider resources like permissions, networking, VPCs, and database instances. This brings me to my second important trait for a great developer platform: It needs to be powerful and allow flexible implementations.

The basic building block in Crossplane is a Managed Resource from a cloud provider. The great news is that Crossplane includes support for AWS, Azure, GCP, and Alibaba, and the community is adding support for many other providers.

These basic building blocks (the Managed Resources in green) are stitched together as Crossplane Compositions (in yellow) and provide the implementation to the API provided to the developers. This model is formalized in the Crossplane Resource Model (XRM), extending the Kubernetes Resource Model (KRM). More on this in a dedicated blog post. The key here is that the platform builder can build different compositions for different purposes while the developer can focus on the properties of the service she requests. BTW: These compositions can also work with legacy or on-prem services, which is crucial for any team that is on some transformation path.

3: Production-Ready With the Help of K8s

The third trait for a great developer platform is it needs to be treated as a product. This includes many aspects, but one important one is it’s operated in a highly available fashion. The good news is that this is a solved problem: With Kubernetes, we have a way of architecting and running distributed applications. Crossplane builds upon this model. It uses Kubernetes controllers and the concept of continuous reconciliation to run the platform. If something breaks (which it will), Crossplane will examine and fix the state. Your favorite Kubernetes expert will now say something like Operators and control planes. And yes, this is precisely what we are doing. – Sounds like another item on my blogpost backlog to explain what this is all about. 🙂

4: Open Source & Open Governance

The last trait but not least important is that the platform needs to be Open Source. As the developer platform will become an essential part of your software delivery, you will want to ensure that your investments are secured. Crossplane is not only Open Source (Apache 2.0), but as part of the CNCF, it’s also openly governed.


These are my current top traits of Crossplane which makes it in my view an exciting solution for building a developer platform. I’m eager to dive deeper into the community and learn about other perspectives. If you’re using Crossplane today and would like to chat, please reach out!

Disclosure: A previous version of this post was published on my LinkedIn profile.

Keep up with Upbound

* indicates required