Embracing Docker: A Journey from Hesitation to Actually Using It

When Docker first emerged, I was skeptical. I wondered, how is this going to provide any benefit to my current workflow and development tools? How can I actually add this to my toolset?

At the time, I was working with the .NET Framework, so everything needed to run on Windows. Yes, there were and still are, things like Wine, Mono, and other tools floating around that tried to bridge the gap, but realistically, none of that felt like a sensible solution to support what I was doing-day to-day and allow me to replicate the enviroment locally. Besides, all environments were running on a Windows server - yes, there was Windows base images It didn’t feel like it would make my life easier, so I just ignored it, and why should I not? My workflow worked. Depending upon the project, I’d spin up the API, spin up the UI, debug what I needed, stop and start things as required. It was simple, predictable, and local. No real reason to change it.

Until...you hit that situation every developer knows. Something goes wrong in production. You try to replicate it locally, and you just can’t.

So what do you do? You increase logging, then add more detail to the API, add more detail to the UI all to try to trace what’s going on, but you still can’t replicate it. this leads to you guessing, pushing logs, redeploying, and hoping that something gives you a clue.

Moving into a new role that was really .Net Core (then 6) focused, really made it start clicking for me. Having a containerised image of the application - something that actually mirrors the environment it runs in - would have made that and other situations, a lot easier to deal with.

It’s not just about production issues either. It’s development environments.

Everyone’s machine is slightly different. Different OS quirks, different setups, different versions of things installed. With containers, you remove that. Same base image, same setup, same behaviour, and It doesn’t matter if someone’s on Windows, Mac, or Linux, you're all running the same thing because it uses the same image to create the container.

And if a new joiner comes in? Instead of a long setup guide and a load of back-and-forth, it’s just:

Everything’s there. Dependencies, services, database, all ready to go (mostly - you might need to run some Database scripts depending upon the configuration/setup process)

I remember someone on a MacBook Air having to jump through hoops just to get things running because we were building everything around Windows. They ended up containerising SQL Server just to get the API running locally. That should've been a bigger warning flag at the time, that we were behind the times.

Fast forward to now, and I've started to use Docker across everything.

This blog is a good example. The UI is written in Blazor and containerised. The API is written in Go and containerised (separate post on why I split those and shifted from a singe monolith blazor application coming soon). The database is MySQL, also containerised - all running on a single VPS for only around £9 a month (thank you OVH.com!) with ample resources left over for all of my other hobby projects.

That still feels a bit mad to say out loud. Not just that it works, but how much headroom there is for more projects on top of it because the final images are so small. No more battling IIS to deploy an application or making sure that an environment has the right runtime installed to execute the latest application, but ensuring that it won't break others.

Honestly, in hindsight, I wish I hadn’t avoided it for so long. Yes, at the time, there were genuine reasons. Framework limitations, the ecosystem not being as mature, and just not needing it, but really, a lot of it was also just not taking the time to properly understand it.

These days, with AI tools like ChatGPT, Codex, Claude etc, along with sandbox environments, the barrier is even lower. You can ask questions, experiment, break things, and learn quickly - which is what I do on a daily basis.

I’m now at the point where I want all of my personal projects to be containerised by default. Especially anything that’s going to run as a web app, because It just makes sense.

No more “works on my machine”; no more environment drift; just something you can spin up anywhere and know it’ll behave the same.

A reflection on this post and what I've written: I've realised that Docker didn’t suddenly become useful overnight; I just reached a point where I could actually see where it fits, and I love that!