What If Every Cozystack Change Became a Commit? en

Cozystack exposes platform services as Kubernetes API resources, e.g. Postgres, Redis, Bucket, Kubernetes. Users interact in the usual ways: kubectl, a GUI (Cozystack dashboard), or even feeding their AI agents through an MCP. But who is making all these changes? And why did they do it? Git seems far away.

But it doesn't have to be.

What if every platform change automatically appeared as clean YAML in Git? Fully automated. Just a silent layer that turns API activity into a durable, readable history of infrastructure intent.

The immediate win is auditability: instead of digging through logs or dashboards, teams get versioned history they can inspect, diff, and share.

Think of it as reverse GitOps: instead of Git driving the platform, the platform continuously writes its intent back to Git.

In this talk, I'll explain why Cozystack is a natural fit for this model, show it live, and explore what platforms gain when Git stops being the interface — and starts being the memory.

The GitOps Paradox: Why Your Devs Need an API You Don't Want to Build en

Platform teams face a paradox: developers need simple APIs and UIs, but building and maintaining them is a huge operational burden that pulls teams away from core platform work.

This session coins "Reverse GitOps," an API-first pattern that solves this by placing a light Kubernetes control plane in front of your Git repository. We'll show how platform teams can define simple CRDs that act as a declarative API for their platform, which can then be used to build GUIs (Backstage/Headlamp) or to allow devs and AI agents to interact with the platform programmatically.

When a user interacts with this API, the open-source `gitops-reverser` operator translates their high-level intent into a clean Git commit. This commit creates a pull request, preserving your existing review process. Once merged, this simple CR can be "exploded" into a full set of production-ready manifests by tools like KRO or Crossplane, integrating with your existing GitOps workflow powered by tools Flux or ArgoCD.

Bringing Pull Requests to Life with GitOps en nl

Kubernetes is the standard for reliably running and managing container applications and is being adopted by more and more organizations. GitOps is a modern approach that combines the benefits of version control and CI/CD pipelines with Kubernetes. By declaratively describing the desired state in Git and utilizing a CD tool like ArgoCD, teams can quickly and reliably deploy their latest developments.

Of course, we start with a brief recap of Kubernetes and GitOps, but then we quickly dive into the practical aspects. I'll demonstrate how, in a small company (25 people), we use Kubernetes to run production code (Azure AKS, Helm, Github, MongoDB Atlas, etc.). I'll also show how, for every pull request, we create a temporary environment used to perform all integration tests. This environment includes a database, other microservices, and even DNS records and certificates. Only with a successful end-to-end test can the pull request be merged. And after merging? The new code automatically goes to production without downtime. And the temporary environment? Thrown away automatically.

The talk will show how GitOps and ArgoCD help a small company (~25 persons) to run production on Kubernetes. Simon will demonstrate the use of ApplicationSets and Helm to deploy a pull request before it's even merged so that you can focus on your change instead of general test environments.

GitOps is a very interesting topic that I actively missed in recent visits I did to conferences: I'm very enthusiastic about the goodness it brings and that's why I decided to create a talk. I already gave the talk in Dutch for the first time on Dotned Saturday in May (https://dotnedsaturday.nl/sessions/breng-je-pull-requests-tot-leven-met-kubernetes-gitops-en-argocd/), and I would love to give it to a larger audience.

I can give it both in English or Dutch: and I at least need 45 minutes because I do live demonstrations.

Breng je pull requests tot leven met Kubernetes, GitOps en ArgoCD en nl

Kubernetes is de standaard voor het betrouwbaar draaien en beheren van containerapplicaties en wordt door steeds meer organisaties gebruikt. GitOps is een moderne werkwijze die de voordelen van versiebeheer en CI/CD-pipelines combineert met Kubernetesbeheer. Door het declaratief beschrijven van de gewenste toestand in Git en het gebruik van een CD-tool zoals ArgoCD, kunnen teams snel en betrouwbaar hun laatste ontwikkelingen live zetten.

Natuurlijk beginnen we met een korte recap van Kubernetes en GitOps maar daarna gaan we snel de paktijk in. Ik laat zien hoe we in een klein bedrijf (25 man) Kubernetes gebruiken om productie code te draaien (Azure AKS, Helm, Github, MongoDB Atlas enz.). Ook laat ik zien hoe we voor elke pull request een tijdelijke omgeving opbouwen die gebruikt wordt om alle integratie testen uit te voeren. Deze omgeving bevat alles wat nodig is: een database, andere microservices en zelfs DNS records en certificaten. Alleen bij een succesvolle integratie test kan de pull request gemerged worden. En na het mergen? Dan gaat de nieuwe code vanzelf en zonder downtime naar productie. En de tijdelijke omgeving? Die ruimen we natuurlijk automatisch op.

Met deze presentatie wil ik graag laten zien hoe je met Kubernetes en GitOps je DevOps team naar een volgend niveau kunt tillen. Ook als je team niet groot is!