Dockerize an App

You have an app that runs on your laptop. It works. Then a teammate clones it, runs the same commands, and gets a wall of errors - a missing library, the wrong language version, a database that isn't there. You spend an afternoon over a screen-share fixing their machine instead of building anything.

This weekend you're going to fix that for good. You'll take a small web app, put it inside a container, and end up with something anyone can run with one command - same versions, same dependencies, same database, every time. No "works on my machine."

What you'll build

A small Python web app (Flask) running inside a Docker container, talking to a Postgres database in a second container, the two wired together with a single compose file. By the end you'll bring the whole stack up with docker compose up and shut it down with docker compose down, and you'll have an image you can tag and push to a registry for someone else to pull and run.

The stack

Built on your machine

This is a build-on-your-machine project, not a run-in-the-browser one. Every command here you run in your own terminal. You need Docker installed before you start - get Docker Desktop (macOS, Windows) or Docker Engine (Linux) from docker.com, then confirm it's alive:

docker --version
docker run hello-world

If hello-world prints a friendly message, you're set. If it can't connect to the Docker daemon, start Docker Desktop (or run sudo systemctl start docker on Linux) and try again.

You'll also want Python 3 on hand for the first couple of phases, though by the end the container holds its own Python and your machine's version stops mattering - which is the whole point.

Rough time

About a weekend, in four sittings:

• Phase 1 - the "works on my machine" problem, and your first Dockerfile that builds and runs.
• Phase 2 - a real Dockerfile: caching, .dockerignore, a slim base, a non-root user.
• Phase 3 - docker compose to run the app and a Postgres database together.
• Phase 4 - ship it: environment variables, secrets, a healthcheck, and pushing to a registry.

What you'll learn

• The difference between an image (the recipe) and a container (a running instance of it).
• How Docker's layer cache makes the difference between a 2-second rebuild and a 2-minute one.
• Why the order of lines in a Dockerfile matters more than almost anything else.
• How containers find and talk to each other on a network.
• How to pass configuration in without baking secrets into the image.
• How to hand your image to someone else so they run it with no setup at all.

Open a terminal, make a folder for this project, and turn to Phase 1.