Beyond basic service definitions, Docker Compose offers features for real-world use — environment management, health checks, dependency conditions, profiles, networks/volumes configuration, scaling, and overrides — that make it more powerful for development and complex stacks.
services:
app:
build: .
env_file: .env # load environment variables from a file
environment:
- NODE_ENV=production
ports:
- "${PORT:-3000}:3000" # variable substitution with a default
Compose supports .env files, environment variables, and variable substitution (${VAR:-default}) for flexible, environment-specific configuration.
services:
db:
image: postgres:16
healthcheck: # define how to check the service is healthy
test: ["CMD", "pg_isready", "-U", "postgres"]
interval: 5s
retries: 5
app:
build: .
depends_on:
db:
condition: service_healthy # wait until db is HEALTHY (not just started)
depends_on with condition: service_healthy (plus a healthcheck) ensures a service waits until its dependency is actually ready — not just started — solving the common "app starts before the database is ready" race.
PROFILES → group optional services (e.g. only start "debug" tools when wanted):
docker compose --profile debug up
OVERRIDE files → docker-compose.override.yml auto-merges (dev overrides);
or -f compose.yml -f compose.prod.yml for environment-specific configs
SCALING → docker compose up --scale worker=3 (run 3 instances of a service)
NAMED VOLUMES & NETWORKS → declare and configure them at the top level
Understanding advanced Docker Compose features is valuable for using Compose effectively in real-world development and complex stacks, building on basic service definitions.
While basic Compose defines services, the advanced features address real needs: environment management (.env files, variable substitution with defaults) enables flexible, environment-specific configuration without hardcoding — important for using the same compose file across different settings. Health checks with dependency conditions (depends_on with condition: service_healthy) solve a very common, frustrating problem — the race where an application container starts before its database is actually ready to accept connections, causing startup failures; understanding how to make services wait for genuine readiness (not just container start) is practically important for reliable multi-container startup. Profiles (selectively starting optional services like debug tools), override files (layering environment-specific configurations, e.g. dev overrides or production configs), and scaling (running multiple instances of a service) extend Compose for varied workflows and environments.
These features make Compose suitable for sophisticated development environments and complex application stacks rather than just trivial setups.
Since real development and complex applications need configuration flexibility, proper startup ordering (readiness, not just start), and environment-specific setups, and since Compose's advanced features (env management, health-check-based dependencies, profiles, overrides, scaling) address these needs, understanding advanced Docker Compose is valuable, practically-relevant knowledge for using Compose effectively in real projects, elevating it from basic multi-container startup to a robust tool for managing complex, configurable application stacks — with the health-check dependency feature in particular solving a common real-world startup reliability issue.