Crossplane and Argo CD: Automating Developer Workflows from Code to Production

In a previous post, we talked about how Argo CD and Crossplane can help you manage application stacks without pulling your hair out. We got into how you can unify infrastructure and application management by combining these tools. But today, we’re cranking it up a notch. I’m going to show you how you can take things even further, automating everything from GitOps pipelines to spinning up cloud resources — all with just one manifest.

Sounds good? Let’s get into it.

I also covered this in my video on the DevOps Toolkit here if you wanted to follow along visually.

The Power of One Manifest

Here’s the deal: Developers shouldn’t need to worry about setting up repos, configuring pipelines, or managing infrastructure. What they need is to focus on writing code. Simple, right? But reality is often more complicated. We’ve got CI pipelines, databases, cloud resources... and if we’re not careful, all of that gets in the way.

So, what if I told you we could handle all that stuff with a single manifest? You write some YAML, push it to Git, and everything else just happens.

Here’s how I envision it:

1. Repository Creation: You push your manifest, and boom — a GitHub repo is created with the initial source code, CI pipelines, and everything you need.
2. CI Pipeline: Next, a pipeline kicks off to build binaries, run tests, and push images to a container registry.
3. GitOps with Argo CD: Argo CD (or Flux, if that’s your thing) syncs everything from Git to the Kubernetes cluster. No manual kubectl commands. It’s all automated.
4. Database Creation: Want a PostgreSQL database in AWS? Done. The manifest triggers Crossplane to provision it for you.

From the developer’s point of view, this is a dream. One manifest, one push, and everything’s set up. No need to mess with infrastructure. You can get straight to building your app.

Crossplane in the Driver’s Seat

So how do we actually pull this off? It all comes down to Crossplane. Crossplane lets you create compositions — reusable configurations that take care of the complexity under the hood. Think of it as a black box that handles all the infrastructure grunt work, but only exposes the parts developers care about.

Say a developer wants to start a new project in Go with a PostgreSQL database on AWS. All they do is write a simple manifest like this:

They push that to Git, and Crossplane takes over from there:

• Repo? Check. GitHub repo gets created with the source code, CI pipelines, and Kubernetes manifests.
• CI Pipeline? Running. GitHub Actions is triggered, builds your app, runs tests, pushes images to a registry.
• Database? Done. PostgreSQL database is provisioned in AWS.
• Argo CD Sync? Automatic. Argo CD pulls everything into the cluster and gets your app running.

This way, developers don’t get bogged down with infrastructure setup. They focus on the high-level stuff, and Crossplane handles the rest.

GitOps Keeps It All in Sync

Now, let’s talk GitOps. We’re not just creating a bunch of stuff and hoping it sticks. We need it all synced and managed continuously. That’s where Argo CD (or Flux) comes in.

As soon as you push your manifest, Argo CD detects the changes, pulls everything into the cluster, and keeps it in sync. So, if something in your repo changes — Argo CD picks it up and automatically updates your environment.

And the best part? It’s all Git-driven, meaning everything is traceable, versioned, and secure. No more messing around with manual kubectl commands.

Scaling This in the Real World

This all sounds great in theory, right? But what happens when things get more complex? What about when a developer needs more customization, like specifying a specific database version or enabling some custom workflows?

That’s where Crossplane compositions come into play again. These compositions are flexible and reusable, which means you can add all the customization you need while still keeping the developer’s job simple.

The goal here is to make sure the developer never sees the complexity, but they can still benefit from the power of Crossplane and Argo CD working behind the scenes.

This is just the start. If you’d like to follow each step further and get the exact code blocks to follow the process, see my other article, hosted on the DevOps Toolkit.

Why Upbound is the Perfect Fit

If you’re looking to manage this kind of complexity at scale, Upbound is your best option. When you’re running workloads across multiple cloud providers, you need a way to handle all those different environments seamlessly. That’s where Upbound, powered by Universal Cloud Computing, comes in.

With Upbound, you can build unified control planes that standardize cloud management across providers like AWS, Google Cloud, and Azure. And here’s why that’s a big deal:

• Unified Control Planes: Manage everything — Kubernetes clusters, databases, cloud services — through one consistent interface, across any cloud.
• Custom Abstractions: With Crossplane at its core, you can create custom abstractions that hide the complexity of infrastructure while exposing easy-to-use APIs to developers.
• Automation and Security: GitOps workflows, automated CI/CD pipelines, and built-in security ensure everything is smooth, traceable, and secure.

Upbound gives you the tools to standardize and scale your cloud operations, while letting your developers focus on building great apps. You get the power of multi-cloud flexibility with the simplicity developers crave.

Conclusion

This is where we’re heading. Developer automation powered by Crossplane, GitOps with Argo CD, and a platform like Upbound that brings it all together. You push a manifest, and everything else just happens.

If you have any questions for me or want to dive deeper into DevOps, GitOps, or platform engineering principles, come to my fireside chat later this month, on October 29th at 8 am PT / 5 PM CEST.