Docker Compose Visualizer & Config Analyzer

Paste a docker-compose.yml and watch it turn into a live architecture map: services as connected nodes, tech and versions, ports, networks, volumes, startup order and a scored list of configuration mistakes with fixes. Free, no sign-up, runs in your browser.

1
PasteAdd a compose file
2
ParseRead services
3
AnalyzeCheck for mistakes
4
VisualizeDraw the architecture
Health scorePaste a file to score it
docker-compose.yml

Architecture map

Every service becomes a node with its tech, version, ports and networks. Click one to highlight what it depends on and what depends on it.

Mistake detection

Unpinned tags, hardcoded secrets, exposed databases, port clashes, missing networks, circular dependencies and more, each with a fix.

Private by design

Your file is parsed in your browser and never uploaded. Share links keep the YAML inside the URL hash only.

User guide

Five steps from a raw docker-compose.yml to a clear picture of your stack.

  1. Add your file

    Paste YAML into the editor, click Upload, or drop a file onto it. Not sure where to start? Pick one of the 13 samples, grouped as clean, popular stacks, patterns and "learn from mistakes".

  2. Watch the workflow

    The four-step strip lights up as the file is parsed and analyzed. The ring shows a health score from 0 to 100, with tiles for services, networks, volumes, ports, errors and warnings.

  3. Explore the architecture

    Click a service to highlight what it needs and what needs it. Use the legend bar to hide arrow types or highlight a tech group, the network chips to filter, and the search box to find a service. Drag to pan, zoom with + / − or Ctrl + scroll.

  4. Open the detail tabs

    Services & tech lists images and versions. Ports shows exposure. Networks & volumes shows who shares what. Startup order shows the start waves. Issues lists every mistake with a fix.

  5. Fix, export, share

    Edit the YAML and the diagram updates live. Export SVG or PNG for docs, a Markdown report for pull requests, or copy a share link. Use Full screen for a bigger canvas.

How to read the diagram

The same legend appears as a bar above the diagram. Click an arrow type to show or hide it, or a tech group to highlight it.

SignMeaning
Solid indigo arrowdepends_on. The arrow points to the service that is needed first. A "healthy" label means it waits for a healthcheck.
Dashed grey arrowlinks, the legacy way to connect services.
Dotted teal arrowA volume or bind mount used by the service.
Green arrow from Host / InternetA published port, labelled host port → container port.
Coloured left barTech group: database, cache, proxy, queue, search, monitoring, app, storage or other.
Number badgeHow many issues were found on that service. Red means an error, amber a warning, blue a tip.
Teal box / dashed amber boxA named volume / a bind mount from a host path.
Coloured dots under a nameThe networks the service is attached to.

What is Docker?

Docker is an open-source platform that packages an application with everything it needs to run (code, runtime, libraries and settings) into a standard unit called a container. A container starts in seconds, behaves the same on a laptop, a test server or the cloud, and stays isolated from other containers and from the host machine.

Core terms

Image: a read-only template such as postgres:16.
Container: a running instance of an image.
Dockerfile: the recipe for building your own image.
Registry: where images are stored, for example Docker Hub.

Storage and networking

Volume: storage that outlives a container, used for databases and uploads.
Network: a private virtual network that lets containers reach each other by service name.
Port mapping: opens a container port on the host, like 8080:80.

Why use Docker?

Same everywhere

Ends "it works on my machine". Dev, CI and production run the same image.

Isolation

Each service has its own dependencies, so a Python upgrade cannot break your Node app.

Fast onboarding

A new teammate runs one command instead of installing a database, cache and queue by hand.

Portable

Move the same stack between a laptop, a VPS and a cloud provider without rewriting setup scripts.

Lightweight

Containers share the host kernel, so they use far less memory and start faster than virtual machines.

Easy to scale and automate

Images are versioned and work naturally with CI/CD pipelines and orchestrators like Kubernetes.

What is Docker Compose, and why does the YAML file matter?

Real applications are rarely one container. A typical stack has a web server, an API, a database and a cache. Docker Compose describes all of them in a single docker-compose.yml (or compose.yaml) file, and one command starts the whole thing.

Why the file is important

Single source of truth for services, ports, networks and storage.
Reproducible: the same file gives the same environment on every machine.
Reviewable: it lives in Git, so changes go through pull requests.
Self-documenting: it is the most honest description of your architecture.
Safer than long docker run commands that nobody remembers.

Why YAML?

YAML is human-readable, supports comments and uses indentation for structure. That is also its trap: one wrong space can silently move a setting under the wrong service. A visual check, like this tool, catches that quickly.

docker compose up -d      # start everything
docker compose ps         # see what is running
docker compose logs -f api
docker compose config     # validate the file
docker compose down       # stop and remove

Anatomy of a docker-compose.yml

A small three-service stack with the purpose of each key.

services:                          # every entry becomes a container
  web:
    image: nginx:1.27-alpine       # what to run (pin the version)
    ports: ["8080:80"]             # host:container
    depends_on: [api]              # start order
    networks: [front]              # who it can talk to
    restart: unless-stopped        # survive reboots
  api:
    build: ./api                   # build from a Dockerfile
    environment:
      DB_PASSWORD_FILE: /run/secrets/db_pw
    depends_on:
      db: {condition: service_healthy}
    networks: [front, back]
  db:
    image: postgres:16
    volumes: ["pgdata:/var/lib/postgresql/data"]   # keep the data
    healthcheck: {test: ["CMD-SHELL", "pg_isready"]}
    networks: [back]
volumes: {pgdata: {}}
networks: {front: {}, back: {}}

KeyWhat it doesWhat this tool checks
image / buildWhich image to run, or which folder to build.Missing source, unpinned or latest tags.
portsPublishes container ports on the host.Port clashes, databases open to the world.
depends_onStart order between services.Unknown services, loops, healthy without a healthcheck.
networksWhich services can reach each other.Undeclared or unused networks, dependencies with no shared network.
volumesPersistent data and mounted files.Undeclared or unused volumes, Docker socket mounts.
environmentConfiguration passed to the app.Hardcoded passwords, tokens and keys.
healthcheckTells Docker when the app is ready.Needed by service_healthy.
restartRecovery after a crash or reboot.Services with no restart policy.

Best practices checklist

  • Pin image versions, for example postgres:16, not latest.
  • Keep secrets out of the file. Use .env files or Docker secrets.
  • Publish databases only to 127.0.0.1, or not at all.
  • Add healthchecks and use condition: service_healthy.
  • Use separate networks to isolate the database from the public edge.
  • Use named volumes for data you cannot lose.
  • Set restart: unless-stopped on long-running services.
  • Remove the obsolete version: line and avoid privileged and the Docker socket.

Frequently asked questions

What does the health score mean?

It starts at 100 and drops 15 points per error, 6 per warning and 1 per tip, so a score near 100 means few or no problems were found.

Does depends_on wait until a database is ready?

Only with condition: service_healthy and a healthcheck on that service. Plain depends_on waits for the container to start, not for the app inside to be ready.

What is the difference between Docker and Docker Compose?

Docker runs single containers. Docker Compose is a tool on top of it that starts and connects many containers from one YAML file.

Why is the latest tag a problem?

It points to a different image over time, so the same file can behave differently next month. Pinning a version keeps builds repeatable.

Should I remove the version key?

Yes. Modern Docker Compose ignores it and warns that it is obsolete. Older 2.x and 3.x files still load fine in this tool.

Which compose versions are supported?

Any docker-compose.yml or compose.yaml, including Compose Specification files without a version key.

Is my file uploaded anywhere?

No. Parsing and analysis happen in your browser. Share links store the YAML only in the URL hash, which is never sent to a server.