January 20, 2025. It feels like just a day ago that the world was in the grip of some big tech stories, but now it seems like eons. The laptop build from scratch? Yeah, I followed along for the journey, but honestly, my laptop is still the one from 2019. And Stimulation Clicker? You bet—tried it out once and almost had a panic attack, so maybe not that again.

But enough about what other people did. Let’s talk about what I did in ops land this year.

The AI-Infused Era

This year has been all about AI-native tooling. I’ve spent the last few months working on integrating copilots and agents into our platform, but let me tell you—my codebase is a lot more “AI-assisted” than I’d like to admit. It’s like having a co-pilot who thinks it’s an actual pilot and keeps trying to take over.

One of the biggest lessons? AI copilots aren’t perfect. They can be pretty damn helpful, but they also throw up their hands at the weirdest times, especially when dealing with edge cases. I’ve had more than one night where my copilot decided it knew better about how our eBPF-based tracing worked and started making changes that caused a cascade of errors.

The eBPF Journey

Speaking of eBPF, this year solidified its production-proven status. We’ve been using it for months now to trace application performance at the kernel level, and I must say, it’s become one of those tools where you wonder how you ever lived without it. But like anything else, there’s a learning curve.

One particular debug session was hellacious. A misconfigured eBPF program caused a spike in CPU usage that led to our application crashing under load. After hours of tracing and profiling, we finally isolated the issue to an incorrect splice() system call within the eBPF program. It was a humbling reminder that even with the best tools, you still need to know what you’re doing.

Wasm + Containers Converging

Another big shift this year has been the convergence of WebAssembly (Wasm) and containers. I’ve been working on a project where we’re using Wasm modules to handle some heavy lifting for our microservices, which are running in Kubernetes clusters. The idea is that we can offload CPU-intensive tasks to Wasm modules without having to spin up full VMs or containers.

It’s worked out pretty well so far, but there have been a few rough spots. For instance, debugging performance issues with Wasm modules has been tricky because you can’t just gdb into them like you would with regular binaries. Instead, it’s more about profiling and tracing the system as a whole to figure out where the bottlenecks are.

Multi-Cloud as Default

Multi-cloud was another theme of 2024 that carried over into 2025. We’re now running our applications across multiple cloud providers—Azure, AWS, GCP—and it’s been both exciting and frustrating. The flexibility is incredible, but the complexity is a beast.

One particularly memorable incident involved an unexpected outage in Azure due to an unpatched vulnerability in their Kubernetes cluster. It took us hours to diagnose and fix, with everyone blaming each other for not realizing that Azure had different security practices than our internal clusters. This led to some heated discussions about standardizing our ops processes across all cloud providers.

Wrapping Up

Looking back at 2024, I feel a mix of relief and frustration. Relief because the tech landscape is moving in a direction that’s making things more manageable, but frustration because it also means we have new challenges to tackle every day. The AI copilots, eBPF debugging, Wasm performance tweaks—each one feels like a step forward, even if they come with their own set of problems.

As 2025 begins, I’m excited to see what the year will bring. Will there be more breakthroughs in AI-assisted ops? Will eBPF and Wasm continue to converge in meaningful ways? Only time will tell, but one thing is certain: I’ll be right here, doing my best to navigate the ever-evolving tech landscape.

Until next time,

Brandon