How It All Started For years I deployed my applications the "classic" way: a server, manual configuration, some bash scripts I hoped wouldn't break at the wrong moment. It worked, but it was fragile. Every environment had its own dependencies, conflicts, and "it works on my machine" moments. Then a colleague said: "Have you tried Docker?" I'd heard the name a thousand times and always put it off, thinking it was for senior DevOps engineers or enterprise infrastructure teams. I was wrong. I installed Docker Desktop one ordinary afternoon, almost out of curiosity. Two hours later I had my first container running. Six hours later I understood why I'd never go back. What Is Docker Desktop and Why It's the Right Starting Point Docker Desktop isn't just Docker with a GUI. It's an integrated environment that brings the Docker engine to Windows (and macOS) natively, with a visual interface that makes abstract concepts tangible: running containers, mounted volumes, real-time logs. The difference from a "CLI only" approach is huge for beginners: seeing what's happening while you learn changes everything. You run a command in the terminal and immediately see the result in the GUI. This visual feedback dramatically accelerates learning. But Docker Desktop isn't a beginner's crutch — it's a professional tool I use daily even now. First Steps: Images, Containers, and Volumes The first conceptual hurdle with Docker is understanding the difference between an image and a container. An image is like a blueprint — a snapshot of the system: OS, dependencies, configurations. A container is a running instance of that image — isolated, disposable, reproducible. The first thing I did was pull an Ubuntu image from Docker Hub and run it. I was inside a complete Linux system, isolated from my Windows installation, without having installed anything on the host. That moment changed my perspective on what "development environment" means. Volumes came right after, when I realized that data inside a container dies with it. To persist data — database files, uploads, configurations — you need to mount an external volume. Docker Networking: Making Containers Talk to Each Other One of the concepts that tripped me up most at first is Docker's bridge network. When you run two containers, by default they can't see each other. You need to explicitly create a network and connect both. I ran an experiment that clarified everything: two Ubuntu containers on the same bridge network, communicating by name — not by IP. Docker handles internal DNS automatically. And suddenly I understood how microservices, containerized databases, and API gateways work — everything connects through Docker networks. Shared Volumes: Data Persistence and File Sharing If networking solves communication, shared volumes solve data sharing. Two containers reading and writing the same files — for example, an app and a background worker — can do this through a volume mounted on both. Docker Desktop shows volumes in the interface with their mount points, size, and which containers are using them. This visibility is invaluable for debugging. Ports and Environment Variables: Configuring Services A container runs in isolation — it's not reachable from outside until you explicitly expose its ports. This explicit mapping isn't a limitation, it's a feature: you know exactly what traffic comes in and where it goes. Environment variables are the correct way to configure containers without modifying code. No hardcoded passwords, no hardcoded environment-specific configs: pass variables at run time and the container configures itself. The Dockerfile: Building Your Own Images Until now I used ready-made images. But Docker's real power comes when you start building your own. The Dockerfile is the declarative file describing how to assemble your custom image. Seven lines containerized a Node.js API I had lying around. Anyone with Docker installed could run it identically, on any OS. No "it works on my machine". Docker Desktop shows the build process in real time and the resulting image in the interface — you can inspect it, see the layers, check the size. Tags and Versioning: The latest Trap The classic beginner mistake: always using the latest tag. Convenient, immediate — and dangerous in production. latest isn't a version number: it's just an alias pointing to the most recent build. If you roll back, you don't know which version you're returning to. The solution is simple: always version your images with semantic tags. latest still exists for convenience, but now you also have 1.0.0 and 1.1.0 to reliably roll back to. It seems like a detail — but it's the difference between a controlled rollback and a 3am emergency. Docker Push: Publishing to Docker Hub The last step of the workflow is publishing images to Docker Hub. From there, anyone on your team — or any CI/CD server — can pull and run them without you sending any files or installation instructions. I published my first image and ran it on another PC with just docker pull and docker run. In thirty seconds, identical to my local version. This is the moment Docker stops being a tool and becomes a paradigm shift in how you distribute software. The Course on Archety I packed this entire journey into a course on Archety: Docker Desktop: Complete Guide for Beginners and Developers. Ten lessons, about two hours, from zero to publishing on Docker Hub — installation, images and containers, bridge networks, shared volumes, port exposure, environment variables, Dockerfile, versioning and docker push. Step by step, no prior container experience required. If you have basic Windows command line skills, you can follow it. Docker isn't the future of deployment — it's already the present. And Docker Desktop is the most direct way to get started.