March 30, 2015. It’s been almost two years since Docker first caught my attention in the tech world, but it feels like just yesterday I was trying to figure out how to integrate this newfangled container technology into our monolithic app at work.

Back then, microservices were a hot topic, with Google’s Kubernetes making waves and CoreOS gaining traction. The 12-factor app philosophy was already well-established, but the industry was still figuring out what it really meant in practice. SRE principles were starting to seep their way into engineering culture, but we weren’t exactly sure how to apply them.

One of our projects at work had been dragging on for months. It involved a monolithic application that had grown organically over years and years—so many layers of dependencies it was almost impossible to trace which piece of code did what. We were struggling with deployment issues, slow feedback loops, and an overall lack of modularity.

I remember sitting in front of my desk, staring at the 12-factor app checklist. It seemed like a good start, but applying it directly to our application felt cumbersome. That’s when Docker came into play. I started tinkering with it during lunch breaks, trying to understand how we could use containers to improve our deployment process.

After a few frustrating weekends, I had something working—I created a container for one of the major services in our app. It was like looking at a new world through a window. Each component could now be isolated and deployed independently without affecting others. But as soon as I tried to scale it up, I hit my first wall.

Our infrastructure wasn’t set up to handle containers yet. We were still heavily reliant on VMs for our deployment pipeline. This meant that even though we had a containerized service, the orchestration piece was missing. I started exploring tools like Kubernetes and CoreOS’s fleet, but they seemed overly complex for what we needed.

One day, during a stand-up meeting, I brought up Docker to my team. The room fell silent as everyone processed the idea of moving away from VMs. There were arguments against it—“What about performance? What if something breaks?” But I couldn’t ignore the potential benefits: faster deployments, better isolation, and easier rollback strategies.

That’s when we hit a roadblock. Our database was a shared resource across multiple services, and moving to containers meant that we needed a new strategy for handling data. PostgreSQL was starting to gain popularity as an alternative to MongoDB, so I started to explore using it more heavily in our stack. However, the transition wasn’t straightforward.

Just before my presentation on Docker at a company-wide tech talk, Slack sent us an email about being hacked. The incident shook everyone, and it made me think even harder about security and how we handle sensitive data. This added another layer of complexity to our database migration plans.

Despite the challenges, I felt like this was the direction we needed to go. So, I spent a few nights arguing with various stakeholders to get buy-in for Docker and containers. It wasn’t an easy sell—after all, it meant a complete overhaul of how we handle infrastructure. But slowly, bit by bit, we started integrating Docker into our stack.

As I write this, the transition is still ongoing. We’ve got some successes, like one of our services fully containerized and deployed with Kubernetes. But there are also failures—services that just won’t work as containers yet. The path to a true microservice architecture isn’t smooth or straightforward; it’s full of obstacles and compromises.

Looking back at the Hacker News headlines from March 2015, I see a reflection of what was happening in tech during those times: a mix of excitement about new technologies like Unreal Engine and React Native, mixed with real-world issues like security breaches and company changes. It feels like we’re living through one of those key transitions that change the way we work.

For now, I’ll keep pushing forward, one container at a time. The journey to microservices is far from over, but it’s worth it for the improvements in our deployment pipeline.

---

March 30, 2015 - A day in the life of an engineer trying to embrace Docker and containers as part of the shift towards microservices.