From "It Works On My Machine" to Docker Mastery: A Beginner's Guide

Harshil Srivastava — Sat, 15 Aug 2026 06:21:26 +0000

Introduction

Let's face it now. We spend hours in coding, adjusting dependencies and building a very cool app. But when you try to deploy it and send it to your friend to check out your awesomeness... nothing works. Then your friend starts complaining that your app is asking for some modules and dependencies and then your reply is one of the most common replies in the developer field, "It Works On My Machine".

If you are tired of this situations then it looks like you need to learn about Docker. In this blog we will try to understand what Docker is, why it was created and how it had solved one of the most problematic situations occur in software development and deployments.

The Pre-Docker Era: One Server, One App

To understand why Docker is so important in today's IT industry, we need to look at history for it. In the early days when applications were used, companies ran them on physical servers in data centres. The rule was simple but inefficient: One application per server. To understand it in simple words, One Laptop for One App.

If a small amount of people (like 200) were using the application a single server was good enough to handle that. But when a big amount (like 2000) of people tries to use that application, the server might crash as it is not capable to handle that much amount of traffic. So to solve this situation companies have to buy an entirely new server, which is expensive, slow, and terrible for the environment.

The Virtual Machine Era: Better, but Heavy

Virtual Machines (VMs): If you want to run Linux OS and you have Windows OS you do not need to buy an another Laptop for it. Instead you can install an application like VirtualBox (its an open source software which lets you run a second operating system inside your current computer) and then inside that software, you open a window and turn on Linux. Look how cool it is, your Windows (Host) OS Laptop is running Linux (Guest) OS in it without buying another laptop. Even if the Linux gets a virus, you can just close or delete the virtual window, without affecting your Windows OS.

Hypervisor: It helps in splitting a single physical server into multiple virtual servers.

But here also we had a problem: Every VM must have its own Operating System (OS). Suppose you need to run five different or same apps then you need five different OS for each of them. This consumes massive amounts of RAM, CPU, and storage just to keep the OS alive, leaving less resources for the actual app.

Enter Containers: The Ultimate Solution

Tech giants like Google and Amazon realised they need isolated environments without the heavy burden of a full OS every time. This led to Containers.

Imagine you want to ship a car, a piano, and some furniture across the world. Instead of figuring out different transport methods for each, you put them all in standardized steel boxes—containers.

In software field, a container is a box that holds your application code, its dependencies, and its system libraries. It isolates the application so it has no idea what is happening outside of it. It runs directly on the host operating system's kernel, making it lightweight and super fast to start. Docker is simply the most popular platform or tool that allows us to create, deploy, and manage these containers.

Containers vs. Virtual Machines

Virtual Machines: Hardware -> Host OS -> Hypervisor -> Guest OS -> Application. (Heavy, slow to start).
Containers: Hardware -> Host OS -> Container Engine (like Docker) -> Application. (Lightweight, starts in seconds).

If you think after this container concept came there will be no need of VMs anymore, you are wrong. In today's modern Cloud Architecture, containers often run on top of virtual machines!

Breaking down: Images vs. Containers

The two most confusing terms for beginners are Images and Containers. Here is the simple way to understand them:

The Recipe Analogy: Imagine you make an amazing noodle soup. You can't ship a hot bowl of soup to your friend in another country. Instead, you send them the recipe. The recipe is the Docker Image (the instructions). When your friend follows the recipe and makes the soup, that running soup is the Container.
The Programming Analogy: For the coders out there, a Docker Image is a Class, and a Container is the Object (the running instance) of that class.

Under the Hood: Docker Architecture

Docker operates on a Client-Server architecture.

Docker CLI (Client): This is your terminal where you type commands (like docker run).
Docker Daemon (Server): It listens to the CLI via REST APIs and manages Docker objects.
Containerd & runc (Runtime): The daemon doesn't actually run the containers; it passes the job to runtimes. runc is responsible for starting and stopping containers, while containerd manages the image pulling and networking.

Getting Your Hands Dirty: Essential Docker Commands

After installing Docker Desktop, here are some commands that you will use everyday:

docker run <image_name>: Pulls the image from Docker Hub(if you do not have it locally) and starts the container. Try docker run hello-world!
docker run -it ubuntu: Pulls the image of Ubuntu from the Docker Hub in an interactive environment so you can execute Linux commands right inside the container.
docker ps: Lists all the running containers.
docker ps -a: Lists all the containers even the stopped ones.
docker stop <container_id>: Stops the container.
docker rm <container_id>: Removes the container.
docker images: Lists all the images downloaded on your local system.

Exposing your apps: Port Forwarding

If you run a web server like Nginx inside your container using docker run nginx, you would not be able to view it in your browser natively. Why? Because the container is isolated.

You need to map the port from your local system to container's internal port:
docker run -p 8080:80 nginx
This command tells the docker that, "Any traffic from localhost:8080 on my computer funnel it through the tunnel to port 80 inside the container."

Making Your First Image: The Dockerfile

If an image is a recipe, then the Dockerfile is where you write that recipe. It is a simple text file in which the instructions are written to how to build your application.

#1. Start with the base image (ubuntu)
FROM ubuntu 

#2. Run commands during the build process
RUN apt-get update

#3. What container should do when it starts 
CMD ["echo", "Hello, My name is Docker!"]

To build this image, simply run docker build -t my-first-image . in the same directory. Once built, now you can share this with anyone in the world. It will work exactly the same way it did on your system.

Conclusion

Docker has completely changed how we develop, ship and run software. By packaging the application into a lightweight and isolated container, it finally puts an end of "It Works On My Machine" excuse. If you think this is the end then wait my friend it is just the tip of an iceberg. From there we will discuss Docker Compose, Docker Volume and Kubernetes in upcoming blogs.

DEV Community: Harshil Srivastava