Docker and Podman both implement OCI runtimes, share the image format, and accept most of the same commands. The real decision comes down to three questions: is a central daemon acceptable, does rootless cover your ports and volumes, and can the team keep its existing Compose assets. This article answers those three; it skips the history.
What the Architecture Difference Actually Changes
Docker: docker CLI ──HTTP──▶ dockerd (daemon)
└── containerd └── runc
every container hangs under dockerd
Podman: podman CLI ──fork──▶ conmon (one per container)
└── runc / crun
no central daemon
The Docker client calls dockerd over a Unix socket, and dockerd schedules every container, network, and volume. The direct consequence is a single point of failure: if dockerd dies, all management operations stop immediately (the container processes themselves may keep running). The subtler consequence: any process that can read and write /var/run/docker.sock is equivalent to host root, so mounting that socket into a container is a classic privilege-escalation path.
Podman forks a conmon per container directly from the CLI, with no resident daemon. There is no daemon single point and no local REST API surface by default. The trade-off is no shared background manager across users; cross-user state lives in each user's own space.
Security: The Limits of Rootless
Rootless means running containers as an ordinary user, with processes inside mapped through user namespaces to unprivileged host UIDs. An attacker who breaks out of the container lands as a normal user: no access to sensitive host files, no direct system control.
| Capability | Docker | Podman |
|---|---|---|
| Native rootless | needs the dockerd-rootless-setuptool.sh helper |
out of the box |
| Automatic userns remapping | manual | automatic |
| Rootless networking (slirp4netns) | available after the plugin | native |
| Concurrent multi-user | limited (single daemon) | per-user namespaces |
Rootless is not free. Confirm three things before migrating:
- Ports below 1024: an ordinary user cannot bind 80/443 directly. Forward from a high port, or keep a rootful mode.
- Volume ownership: userns remapping changes the UID seen inside, so writes to a bind mount can fail with permission denied. Use
--userns=keep-idor fix the host directory owner. - Network throughput: rootless goes through slirp4netns NAT and is slower than rootful. Network-sensitive workloads want rootful + macvlan.
At the image layer both share OCI, so Trivy and Grype scan either. Signing and SELinux differ: Podman can enforce --signature-policy and generates correct SELinux labels by default on Fedora/RHEL; Docker needs extra tooling for both.
Compatibility: How Far Does an Alias Go?
Everyday commands line up:
docker run -d --name web -p 8080:80 nginx:alpine
docker build -t myapp .
docker pull/push/exec/logs/ps/rm/stop/start/inspect
docker network create/ls/rm
docker volume create/ls/rm
That is why alias docker=podman is common. What actually trips migration:
| Capability | Docker | Podman | Note |
|---|---|---|---|
| Docker Compose | built in as docker compose |
needs podman-compose or the socket shim |
covers most cases |
| Docker Swarm | built in | unsupported | use Kubernetes or Nomad |
| Docker Desktop | GUI and VM included | needs podman machine |
similar but lighter |
| BuildKit features | mature caching and multi-stage | Buildah backend | occasional differences on complex Dockerfiles |
--device / GPU |
mature | mostly works | test per driver |
Dockerfiles themselves are compatible: Podman builds with Buildah and supports FROM/RUN/COPY/CMD; only exotic BuildKit features need rewriting.
Three Places Podman Genuinely Wins
Single-host services and edge devices: podman generate systemd produces unit files, so a container starts at boot, restarts on failure, and logs to journald like a native service:
podman generate systemd --name web --files --new
# creates container-web.service; copy it to /etc/systemd/system/
systemctl enable --now container-web
Local validation of Kubernetes config: podman play kube deployment.yaml runs Pod YAML without installing a cluster, closing the "works locally, fails in production" gap.
Multi-tenant CI and shared dev machines: each user or job runs its own rootless Podman with no interference and no privileged runner. Docker's single daemon needs extra permission work here.
Migrating from Docker to Podman
# install
sudo apt install podman podman-compose # Debian/Ubuntu
sudo dnf install podman # Fedora/RHEL
brew install podman && podman machine init && podman machine start # macOS/Windows
# verify
podman version && podman ps -a && podman images
# optional: command alias
alias docker=podman
# two Compose routes
podman-compose -f docker-compose.yml up -d
systemctl --user enable --now podman.socket
export DOCKER_HOST=unix:///run/user/$(id -u)/podman/podman.sock
docker-compose up -d
The usual migration pitfalls:
| Pitfall | Cause | Fix |
|---|---|---|
| Cannot bind 80/443 | rootless cannot bind privileged ports | forward from a high port, or use rootful |
| Mounted directory not writable | userns remap makes UIDs differ | --userns=keep-id or change the owner |
| Lower network throughput | slirp4netns NAT overhead | rootful + macvlan in production |
| Slower large image builds | Buildah caching differs from BuildKit | reuse --layers; keep Docker for complex builds |
Decision Guide
| Your situation | Recommendation |
|---|---|
| Team has lots of Compose and Docker experience | Stay on Docker; migration costs more than it returns |
| Single-host service, edge device, IoT | Podman (systemd integration + rootless) |
| Shared dev machines / multi-tenant CI | Podman (per-user rootless isolation) |
| Security or compliance sensitive | Podman (signing + rootless + SELinux) |
| Production Kubernetes cluster | Independent of the local engine; run containerd / CRI-O |
| macOS / Windows desktop development | Either; Podman Desktop is available |
Bottom line: choose Podman when the pain is security, multi-user isolation, or single-host service management. Stay on Docker when the team already has Compose files and troubleshooting knowledge. If you run both, do not let alias docker=podman hide the Swarm and Compose gaps.
Pair this with the Docker command cheat sheet and the Kubernetes command cheat sheet; the docker-to-compose tool helps you compare compose and Kubernetes manifest structure.
Reproducible Results
Run the same commands on both engines and the differences surface immediately:
docker --version && podman --version # two versions side by side
docker run --rm hello-world # works unchanged after the alias
podman run --rm docker.io/library/hello-world # native Podman wants the fully qualified name
Three differences are visible at once: Podman has no daemon to inspect (systemctl status docker has no counterpart), image names default to fully qualified (docker.io/...), and rootless needs extra configuration to bind 80/443.