Reflections on June 15, 2020: The Pandemic’s Grip and Platform Engineering’s Rise

June 15, 2020. A day that seemed like just another Monday but was actually the midpoint of a year that would forever change how we work and live.

The Background

Platform engineering was starting to formalize itself as a distinct discipline. Tools like Backstage were gaining traction as internal developer portals emerged as essential hubs for our teams. SRE roles were proliferating, bringing operational rigor to development practices. Meanwhile, the pandemic had shifted everything into remote-first gear at an unprecedented pace. As someone who already worked remotely, I was fortunate but also found myself juggling more than ever.

The Context

That month saw tech news with a mix of excitement and controversy. Apple’s announcement to switch to its own processors for future Macs was both a validation of ARM’s capabilities and a sign of the ongoing shift in hardware ecosystems. Meanwhile, the TikTok scandal and app bans in India underscored geopolitical tensions that were increasingly affecting our industry.

On a personal level, I found myself wrestling with some real ops and infrastructure challenges. One particular issue stood out: managing stateful services on Kubernetes.

The Problem

We had several stateful applications running in a Kubernetes cluster, but every time there was an update or deployment, it felt like we were wading through quicksand. Each application’s data was tightly coupled with its environment, making rollbacks and migrations a nightmare. The complexity was only increasing as the number of services grew.

I decided to dig deep into eBPF (extended Berkeley Packet Filter), hoping it might provide some insights or tools to address our pain points. After all, eBPF had been gaining attention for its ability to extend kernel functionality without modifying the kernel itself—a powerful tool in my toolbox.

The Journey

Armed with a renewed interest in eBPF, I started exploring how we could use it to manage state transitions more effectively. But as often happens with technology, the theory was great, but the implementation was fraught with challenges.

I spent days trying different approaches and reading through countless forum posts and documentation. Each attempt brought me closer to a solution but also further into the weeds of kernel programming and C programming in general. I felt like a novice again, constantly debugging, testing, and rethinking my approach.

Meanwhile, ArgoCD and Flux GitOps were maturing rapidly. These tools promised to simplify our CI/CD pipeline management and could potentially help us with some state transitions. After much deliberation, we decided to experiment with them alongside eBPF.

The Outcome

After several iterations, we landed on a solution that combined both approaches. We used ArgoCD for managing deployments and Flux GitOps for ensuring consistency across environments. For the remaining stateful services, we leveraged eBPF hooks to manage data transitions seamlessly.

The result was a much more robust system. Rollbacks became smoother, and deployments were less error-prone. It wasn’t an overnight success but rather a journey that required patience and persistence.

The Reflection

Looking back at June 15, 2020, it feels like a crossroads. The tech landscape was shifting rapidly, with new tools emerging and old ways of doing things being reevaluated. For me, it was about finding solutions in the chaos, learning along the way, and pushing past my comfort zone.

The year ahead would bring more challenges, but I knew that by embracing the unknown and constantly seeking better solutions, we could navigate through the complexities of our rapidly changing world.

---

This post is a snapshot of what it’s like to work on the front lines of platform engineering during one of the most tumultuous years in tech history. It’s real, it’s honest, and it’s part of my journey.