Every web developer has experienced the "it works on my machine" problem. Docker solves this by packaging your application with its entire environment — code, runtime, system tools, and libraries — into a portable container.
This guide covers what containers are, how to use Docker effectively in web development, and best practices for production.
What is Docker?
Docker is a containerization platform. A container is a lightweight, standalone executable that includes everything needed to run software. Unlike virtual machines, containers share the host operating system kernel, making them faster and more resource-efficient.
Key concepts:
- Image: a read-only template with instructions for creating a container
- Container: a runnable instance of an image
- Dockerfile: a text file with instructions to build an image
- Volume: persistent storage that survives container restarts
- Compose: a tool for defining and running multi-container applications
Dockerfile for a Next.js application
A well-structured Dockerfile uses multi-stage builds to keep images small:
FROM node:22-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
FROM node:22-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build
FROM node:22-alpine AS runner
WORKDIR /app
COPY --from=builder /app/.next ./.next
COPY --from=builder /app/public ./public
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["npm", "start"]
Multi-stage builds keep the final image lean — only what's needed at runtime, not the build toolchain.
Docker Compose for local development
Compose lets you define your entire stack in a YAML file and start everything with one command:
version: "3.8"
services:
app:
build: .
ports: ["3000:3000"]
volumes: [".:/app", "/app/node_modules"]
depends_on: [db]
db:
image: postgres:16
environment:
POSTGRES_PASSWORD: password
volumes: ["pgdata:/var/lib/postgresql/data"]
volumes:
pgdata:
This gives every developer an identical environment — same Node version, same database, same configuration. No more setup documentation.
Best practices
Use .dockerignore: Exclude node_modules, .git, and build artifacts from the Docker build context. This speeds up builds and reduces image size.
Pin base image versions: Use node:22-alpine instead of node:latest. Reproducible builds require explicit versions.
Run as non-root: Containers running as root are a security risk. Create a user in your Dockerfile and switch to it.
Use health checks: Define HEALTHCHECK instructions so orchestration platforms know when your container is ready.
Cache dependencies strategically: Copy package.json and run npm install before copying application code. Docker caches each layer — dependency installation only reruns when package.json changes.
Production deployment
For production, integrate Docker with an orchestration platform. A single Docker container running on a VPS is fine for small projects. For larger applications, use Kubernetes or a managed container service (AWS ECS, Google Cloud Run).
Docker transforms web development workflows. Consistent environments, reproducible builds, and simplified deployments benefit teams of any size.
Adopting Docker for your web project? At Vynta containerize every application we build, ensuring consistent environments from development through production.