Why I Spent Years Running Away From Docker (And Why That Was Silly)

There’s a particular type of regret that hits different when you realize you’ve been making your life harder than necessary. For me, that moment came when I finally understood what Docker actually does—and realized I’d been avoiding it for nearly a decade.

I’m not going to pretend I was alone in this. Plenty of people who run their own servers and self-host applications have the same relationship with Docker that I did: a vague sense that it was probably useful, combined with an even vaguer sense that it was too complicated to bother learning. So we kept doing things the old way, copying files around, managing dependencies, and wondering why our setup broke whenever we updated the operating system or installed something new.

The funny thing is, Docker doesn’t actually solve a complex problem. It solves a straightforward one. But that straightforward problem had become such a normal part of my life that I’d stopped noticing it was there.

The Self-Hosted Chaos Nobody Talks About

When you run your own applications on your own servers, you quickly become familiar with a particular flavor of headache. You install application A, which needs version 3.2 of some library. Then you install application B, which needs version 4.1 of the same library. Suddenly both applications are unhappy. You’re juggling versions, creating workarounds, and hoping nothing breaks when you need to update the system.

Then there’s the knowledge problem. Let’s say you’ve got a setup that works. You’ve tweaked it for six months. It’s fine. But what happens if your server dies? Can you recreate it exactly? Do you remember every configuration change you made? Did you document it? (You didn’t document it.)

I found myself in this exact position multiple times:

• Spending two days trying to get a web application running on a fresh server, only to realize I was missing some obscure configuration file
• Breaking something while trying to update a dependency and having no clean way to roll back
• Running multiple applications that all wanted to use port 80, requiring creative networking solutions
• Keeping detailed notes scattered across various text files, hoping future-me would understand them

This was just… normal. This was how you self-hosted things. Or so I thought.

What I Got Wrong About Docker

My mental image of Docker was something like this: a complicated system for large companies running complex infrastructure. It seemed like overkill for someone like me, just trying to run a handful of services on a single server.

What I actually got wrong was thinking of Docker as a complexity multiplier, when it’s actually a complexity reducer.

Docker’s actual job is remarkably simple. It packages an application along with everything that application needs to run—all the libraries, all the dependencies, all the configuration—into a self-contained unit. That unit runs the same way on any computer. Your laptop, a friend’s server, a cloud provider, it doesn’t matter. It just works.

More importantly, it isolates applications from each other. Your email server and your web server aren’t fighting over library versions anymore. They’re in separate containers, each with their own dependencies. Each one thinks it’s the only application on the system.

The simplicity of this is what I’d been missing. It’s not that Docker makes self-hosting harder—it makes it easier. Significantly easier.

The Years I’ll Never Get Back

I spent actual years avoiding Docker because I thought it would add complexity when I was already drowning in it. I spent hours troubleshooting environment-specific issues. I created fragile setups held together with shell scripts and prayer. I lost sleep over server migrations.

The cost of avoidance was far, far higher than the cost of learning something new would have been.

What gets me is that I had all the warning signs pointing in the right direction. Colleagues mentioned it. Articles recommended it. But I was confident in my current approach (which is a funny way to describe a system that regularly broke), and confidence is a dangerous thing in technology.

Here’s what I’d tell anyone in a similar position: if you’re self-hosting and you find yourself constantly wrestling with dependencies, versions, and configuration files, Docker isn’t something you should eventually learn. It’s something you should learn before you spend five years creating increasingly elaborate workarounds.

The isolation it provides isn’t a luxury feature for enterprise deployments. It’s a basic problem-solving tool that makes running multiple applications on one server straightforward instead of nightmarish.

Would I have picked it up earlier if I understood this? Obviously. But I’m putting it out there now for anyone standing where I was: you’re not missing some hidden complexity. You’re missing a straightforward solution to complexity you’re already dealing with. The time to give it a proper look is today, not after you’ve spent another few years inventing better ways to fail.

Source: Docker solved the mess I created with self-hosted tools, and I wasted years avoiding it