Today I’m launching something brand new: a personal series I’m calling Solo_Leveling Log. This isn’t the typical polished lab build video that i do. This is my raw, unfiltered space to document what I’m learning, what’s tripping me up, how I’m solving it, and what books I’m using to grow. Think of it as a behind-the-scenes journal — one that tracks my leveling-up journey, step by step.
What’s This Series About?
The goal is simple: document the process. Not just the wins. Not just the highlights. But the real stuff — the messy middle where learning actually happens.
You’ll see:
- The concepts I’m studying
- The mistakes I make and how I fix them
- The tools I’m playing with
- And the books I’m learning from
I’ve got a stack of books I’ve been meaning to tackle, and I figured — instead of going through them quietly on my own, why not bring you guys along for the ride? I believe real learning happens in the trenches — when you’re testing, breaking, fixing, and adjusting. That’s what this series is all about.
First Up: Docker Deep Dive by Nigel Poulton
To kick things off, I’m diving into Docker Deep Dive — a no-fluff, straightforward book about containers and Docker. I wanted a better grip on Docker before integrating it more deeply into my lab, and this book seemed like the right call. We’ll walk through it together, chapter by chapter — breaking things down, testing concepts, and applying them to real-world setups.
Chapters 1 & 2 — Key Takeaways
Containers Aren’t New
Docker didn’t invent containers. They’ve been around for a while — but using them was a nightmare. You had to understand the Linux kernel, write a bunch of scripts, and manually manage everything. Docker changed that by making containers accessible. That’s why it exploded.
Docker = What VMware Did for VMs
Docker democratized containers the same way VMware democratized virtualization. With VMware, we could run multiple VMs on a single server — but each one still needed a full OS. Docker flipped the script. Instead of running 10 VMs with 10 OSes, you can run 10 containers that all share the same host kernel. That means:
- Less overhead
- Faster startup
- More efficient resource usage
It’s wild how far things have come.
Two Main Parts of Docker
Docker is made up of two major components:
- The CLI – The command-line interface that you use to talk to Docker
- The Docker Engine – The server daemon that handles all the actual work
When you run a command like docker run, the CLI converts it into an API call and sends it to the engine, which spins up and manages your containers.
A Quick History
Docker wasn’t always Docker. It actually started as an internal tool at a company called dotCloud, which tried to be a Platform-as-a-Service (PaaS) company. The container tooling they built internally ended up being way more valuable than the original business. So they pivoted — dropped the PaaS model and went all-in on Docker. Honestly? Best decision they could’ve made.
What’s Next?
Chapters 1 and 2 are more conceptual — not super technical yet. But in the next entry, we’re getting hands-on. We'll start setting things up and testing out Docker in the lab. Every concept we learn from this book? We’re going to put it to the test.
Final Thoughts
This series isn’t about perfection — it’s about process. About learning .About showing the work. If you’re leveling up too — whether it's Docker, DevOps, or just trying to build your skills — I hope this helps you feel less alone in the process. Thanks for tuning in. Stay geeking, stay curious — and I’ll see you in the next one.
