TL;DR

A forced Kubernetes migration exposed years of deployment debt: scattered manifests, untracked cluster changes, and no single source of truth. We evaluated GitOps tools and chose ArgoCD for its visibility, drift detection, and multi-cluster management. What used to be stressful migrations became predictable, auditable deployments.

The Bombshell

It was a rainy evening when a bombshell landed on our DevOps team.

We were asked to migrate our Kubernetes cluster to another provider for cost optimization. And just when we were catching our breath, came the twist: this might not be the last migration. If performance didn’t meet expectations, we’d be asked to move yet again.

Spinning up a fresh Kubernetes cluster? That was the easy part.

But what really had the team sweating was this: 50+ microservices spread across multiple projects, and no single place where we had the complete manifests—deployments, services, ingresses, secrets, and configmaps.

The Realization

That moment made us pause and realize: yes, our deployments were fast, but our practices weren’t future-proof.

We had serious deficiencies that were waiting to explode:

Scattered manifests: Deployment files were buried inside CI/CD pipelines, scripts, or worse, on developer laptops. It worked… until it didn’t.

Untracked cluster changes: Hotfixes were applied directly on the Kubernetes cluster, bypassing Git. Who did what, when, and why? A mystery.

No single source of truth: Git said one thing, the cluster showed another, and the last pipeline run showed yet another.

Painful rollbacks: Reverting to a previous version meant digging into old pipelines or manual patchwork.

Multi-cluster chaos: Managing Dev, UAT, and Prod meant copy-paste gymnastics, hoping nothing was missed.

The Wake-Up Call

This wasn’t just a list of minor inconveniences. It was a wake-up call. An alarm bell ringing at full volume.

If we continued this way, migrations would fail, audits would flag us, and outages would become nightmares.

We didn’t need another quick fix. We needed a paradigm shift.

The Eureka Moment: GitOps

And then it struck us—the missing piece had been staring at us all along: GitOps.

GitOps was not just a tool. It was a philosophy. A way of treating Git as the single source of truth for our Kubernetes deployments.

It promised exactly what we needed:

  • Single Source of Truth: All manifests in Git, in one place
  • Version Control: Every change tracked, with the ability to roll back instantly
  • Auditability: Full history of who changed what and why
  • Drift Detection: Any manual tampering with the cluster flagged immediately
  • Automated Reconciliation: Clusters automatically sync to match Git
  • Multi-Cluster Consistency: Smooth promotion across Dev → UAT → Prod
  • Stronger Security: No more pipelines pushing into clusters. Instead, clusters pull from Git

This wasn’t just an improvement. It was the answer we had been missing all along.

The Mission: Choosing the Right Tool

But here came the next challenge. There wasn’t just one way to do GitOps.

We had to decide: which GitOps tool would be the best fit for us?

This was no longer just about deployments. This was about survival, about evolving our practices to be stronger, smarter, and future-ready.

We were on a mission—to find the GitOps engine that would become our guiding star.

Flux vs. ArgoCD

The two frontrunners quickly emerged: Flux and ArgoCD.

Flux: Lightweight, GitOps-first, integrates neatly with Git. Great for simplicity and automation.

ArgoCD: Full-fledged dashboard, powerful UI, real-time visibility, role-based access control, and multi-cluster management.

While Flux was elegant, our team needed visibility, control, and confidence—especially with 50+ microservices and multiple environments.

That’s where ArgoCD shone:

  • A beautiful dashboard showing what’s deployed, where, and how healthy it is
  • Easy rollbacks by syncing to a previous Git commit
  • Strong support for managing multiple environments and clusters
  • Alerting and drift detection built in

Why We Chose ArgoCD

At the end of our evaluation, the choice was clear.

We needed not just GitOps, but GitOps with visibility and governance.

ArgoCD became our control tower—managing every deployment, spotting drifts, and keeping our clusters in perfect sync with Git.

What used to be stressful migrations and uncertain rollbacks turned into predictable, auditable, and confident deployments.

Real-World Moments

The shift wasn’t just theory—it showed up in real life, almost immediately:

The hotfix mystery: Earlier, a developer once fixed a production bug with a quick kubectl apply. It solved the issue… until the next pipeline wiped it away. With ArgoCD, such drift is instantly visible, forcing the fix to go through Git where it belongs.

The rollback scare: We once spent two hours patching YAML to restore a stable version. With ArgoCD, rolling back was just a click: sync to previous commit. Two hours became two minutes.

The multi-cluster headache: Before ArgoCD, promoting changes across Dev, UAT, and Prod felt like juggling fire. With ArgoCD, we manage everything from one dashboard with confidence.

Conclusion: From Chaos to Clarity

Looking back, that rainy evening and the bombshell request to migrate clusters turned out to be a blessing in disguise.

It forced us to pause, reflect, and evolve. It pushed us from chaotic pipelines to structured GitOps.

And in ArgoCD, we found not just a tool, but a teammate. A control tower that gave us the confidence to deploy fearlessly.

This wasn’t just another DevOps upgrade. This was a transformation.

Editorial Note

This article was originally published on LinkedIn and has been revised for uk4.in.

Original publication date: 2025-08-23

Original link: https://www.linkedin.com/pulse/from-chaos-gitops-our-journey-argocd-uttam-jaiswal-qhagc/