What is a Docker Image vs a Container?
Understand the difference between a Docker image and a container — blueprint versus running instance — with clear examples and interview tips.
Expected Interview Answer
A Docker image is a read-only, layered blueprint containing the application code, dependencies, and configuration, while a container is a running, writable instance of that image with its own isolated process and filesystem layer.
An image is built once from a Dockerfile as a stack of immutable layers, each layer representing one instruction, and layers are cached and reused across builds for efficiency. When you run `docker run` against an image, Docker adds a thin writable layer on top and starts an isolated process — that combination is the container. You can start many containers from the same single image, each with independent state, network, and process space, but all sharing the same underlying read-only image layers on disk. Deleting a container does not affect the image it was created from, and stopping a container discards its writable layer unless the data was persisted via a volume.
- One image reliably produces many identical containers
- Layer caching speeds up builds and reduces storage
- Containers can be started, stopped, and discarded cheaply
- Clear separation between the immutable blueprint and runtime state
AI Mentor Explanation
An image is like the official coaching manual and kit list for a franchise team, written once and stored centrally. A container is an actual match-day squad assembled from that manual — eleven players on the field, playing a live game with its own scoreboard and outcome. Many different matches can be played from the same manual, each producing an independent live game. If one match ends, the manual itself is untouched and ready to spawn the next game.
Step-by-Step Explanation
Step 1
Build the image
docker build creates immutable, layered, read-only files from a Dockerfile.
Step 2
Store or push
The image is cached locally or pushed to a registry for reuse.
Step 3
Run a container
docker run adds a writable layer and starts an isolated process from the image.
Step 4
Discard or persist
Stopping/removing the container discards its writable layer unless a volume was mounted.
What Interviewer Expects
- Clear distinction: image is static blueprint, container is running instance
- Understanding of the writable layer added at container runtime
- Awareness that one image can spawn many independent containers
- Knowledge that removing a container does not affect the source image
Common Mistakes
- Using "image" and "container" interchangeably
- Thinking a container modifies the original image directly
- Believing an image can only ever start one container
- Forgetting the writable layer is lost when a container is removed
Best Answer (HR Friendly)
“Think of an image as a saved template — like a blueprint — and a container as the actual running thing built from that blueprint. We can spin up many containers from one image, and stopping or deleting a container never touches the original image, so we can always spin up a fresh, clean instance whenever we need one.”
Code Example
# List images (blueprints) on this machine
docker images
# Start two independent containers from the same image
docker run -d --name web1 myapp:1.0
docker run -d --name web2 myapp:1.0
# Remove a container without touching the image
docker rm -f web1
docker images # myapp:1.0 is still listedFollow-up Questions
- What happens to a container’s data when it is removed?
- How does layer caching speed up docker build?
- What is the difference between docker run and docker start?
- How would you persist container data across restarts?
MCQ Practice
1. What best describes a Docker container?
A container is the live, running instance created from an image, with its own writable layer and process.
2. What happens to the source image when a container built from it is deleted?
Images are immutable and independent of any containers created from them; deleting a container never affects the image.
3. How many containers can be started from a single image?
A single image can be used to start any number of independent containers, each with its own runtime state.
Flash Cards
What is a Docker image? — An immutable, layered, read-only blueprint built from a Dockerfile.
What is a Docker container? — A running instance of an image plus a writable layer and isolated process.
Does deleting a container affect its image? — No — the image remains unchanged and reusable.
Can one image start multiple containers? — Yes, many independent containers can run from the same image.