What Is Docker? Containers Explained for Developers

"It works on my machine." Every developer has said it. Every developer has heard it. Docker exists to make that phrase obsolete.

The Problem Docker Solves

Software depends on a specific environment to run: a particular version of Node.js, Python, or Java; certain system libraries; specific environment variables; a database at a precise version. When a developer builds an app, they configure all of this on their own machine.

The problem comes when that app needs to run somewhere else — a teammate's laptop, a test server, a cloud environment. Differences in OS, runtime versions, or library installs cause subtle (and not-so-subtle) failures.

The traditional answer was detailed setup documentation and manual environment configuration. Docker replaces all of that with something better: a container.

What Is a Container?

A container is a lightweight, self-contained package that includes everything an application needs to run:

The application code
The runtime (Node, Python, etc.)
Dependencies and libraries
Configuration files

A container runs the same way everywhere — on your laptop, your colleague's machine, your CI/CD pipeline, or a cloud server. The environment travels with the application.

Think of it like shipping containers in logistics: before standard containers, cargo was packed differently by every shipper, loaded and unloaded differently at every port. Standardized containers made it possible to move goods reliably anywhere in the world without repacking. Docker does the same for software.

Containers vs Virtual Machines

Containers are often compared to virtual machines (VMs), but they're quite different.

A virtual machine emulates an entire computer — its own operating system, kernel, memory, and hardware. VMs are isolated and portable, but heavy: each VM might take gigabytes of space and minutes to start.

A container shares the host operating system's kernel but isolates the application and its dependencies. Containers are:

Lightweight — megabytes, not gigabytes
Fast — start in seconds or milliseconds
Efficient — dozens of containers can run on the same machine a few VMs could handle

| | Virtual Machine | Container | |---|---|---| | OS | Full OS per VM | Shares host OS kernel | | Size | Gigabytes | Megabytes | | Start time | Minutes | Seconds | | Isolation | Strong | Good | | Overhead | High | Low |

Key Docker Concepts

Image

A Docker image is a read-only template that defines what's in a container. It's like a blueprint or a snapshot. Images are built from a file called a Dockerfile.

Container

A container is a running instance of an image. You can start, stop, restart, and delete containers. Multiple containers can run from the same image simultaneously.

Dockerfile

A Dockerfile is a text file with instructions for building an image. Each instruction adds a layer to the image.

# Start from an official Node.js image
FROM node:20-alpine

# Set the working directory
WORKDIR /app

# Copy dependency files
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application
COPY . .

# Expose the port the app listens on
EXPOSE 3000

# Start the app
CMD ["node", "server.js"]

Docker Hub

A public registry where Docker images are stored and shared. Official images for Node.js, Postgres, Nginx, Redis, and thousands of other tools are available here — you don't have to build from scratch.

Docker Compose

A tool for defining and running multi-container applications. Instead of starting each container manually, you describe your entire stack in a docker-compose.yml file:

services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - db

  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: example
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

One command — docker compose up — starts your entire application stack.

A Typical Docker Workflow

1. Write a Dockerfile describing your app's environment
2. Build an image:  docker build -t my-app .
3. Run a container: docker run -p 3000:3000 my-app
4. Push to a registry: docker push myorg/my-app
5. Pull and run anywhere: docker pull myorg/my-app && docker run myorg/my-app

Why Developers Use Docker

Consistent environments

No more environment-specific bugs. Everyone on the team runs the exact same versions of everything.

Fast onboarding

A new developer can clone a repo, run docker compose up, and have a fully working local environment in minutes — no manual setup required.

Isolation

Multiple projects with conflicting dependencies can run on the same machine without interfering with each other.

Production parity

Your development environment closely mirrors production. The same image you test locally is the one that gets deployed.

Foundation for CI/CD and Kubernetes

Containers are the building block of modern cloud infrastructure. Kubernetes — the system that manages containers at scale — operates on Docker images. Understanding Docker is the entry point to understanding how modern applications are deployed and operated.

The Bottom Line

Docker solves one of the oldest problems in software: the gap between the environment where code is written and the environments where it runs. By packaging applications with their entire runtime and dependencies, containers make software portable, reproducible, and consistent. Whether you're working solo or shipping software at scale, Docker is one of the most practical tools in modern development.