A few months ago I started building a new side project. Nothing particularly complicated, just a small application that needed a backend, a frontend, and a database. Docker Compose was the obvious choice because it made running everything together incredibly easy.

The funny thing is that I quickly found myself opening Google over and over again.

“How do I rebuild the containers?”

“Was it --build or --force-recreate?”

“How do I remove the volumes again?”

At first, I found it a little frustrating. I’ve been a developer for years, so surely I should know these commands by heart by now.

Then it hit me.

I don’t use Docker every single day.

At work, I spend most of my time building features, reviewing pull requests, fixing bugs, discussing ideas with the team, and trying to understand business requirements. Docker is just one of many tools I use. Some weeks I barely touch it, while other weeks I use it constantly.

Why would I expect myself to remember commands that I only need once every few weeks?

The best developers don’t memorize everything

For a long time I believed experienced developers had incredible memories. I imagined senior engineers sitting at their keyboards, effortlessly typing every Git command, every Docker option, every Linux flag, without ever opening a browser.

Working alongside experienced developers completely changed that perception.

People Google things all the time.

They read documentation.

They search old Slack messages.

They copy commands from previous projects.

The difference isn’t that they remember everything. The difference is that they know what they’re looking for and they understand why they’re using it.

That distinction is much more important than memorization.

Once I accepted that, I stopped trying to build a perfect memory and started building better notes instead.

Whenever I found myself searching for the same command twice, I added it to a personal cheat sheet. Not every Docker command—just the ones that were genuinely useful for the way I work.

Over time, that little document became one of the most valuable resources I had. Every time I returned to a side project after a few weeks away, I didn’t have to search the internet again. Everything I actually needed was already there.

Understanding beats memorization

Interestingly, the cheat sheet also revealed something about my own workflow.

I wasn’t forgetting Docker because Docker was complicated.

I was forgetting commands because they weren’t the important part.

The important part was understanding what was happening.

Once you understand the difference between rebuilding an image, recreating a container, removing a volume, or simply restarting a service, looking up the exact command becomes a twenty-second task instead of a stressful experience.

That’s something I wish someone had told me much earlier in my career.

Programming isn’t about carrying thousands of commands around in your head.

It’s about building mental models.

If you understand how the pieces fit together, the syntax is just a detail. Documentation exists for a reason, and even experienced developers rely on it more often than people realize.

So if you’re learning Docker and you find yourself repeatedly searching for the same commands, don’t take it as a sign that you’re failing.

Build your own reference instead.

Write down the commands you actually use. Add a short note explaining why you use each one. Keep improving it every time you learn something new.

A year from now, you probably won’t remember every Docker command.

And that’s perfectly okay.

You’ll have something much more valuable: a workflow that lets you get back to solving real problems instead of trying to prove how much you can memorize.