Self-Host Medusa v2 on Hetzner with Coolify: Production-Hardened Docker Setup (2026)

Most Medusa deployment guides stop at "it works on localhost." Production breaks in different ways — CORS misconfiguration locks you out of the admin panel, point-release upgrades crash the build, ARM images need multi-arch Docker builds, and the workflow engine loses state on restart if you forget to switch from in-memory to Redis. I am Manoj, implementation lead at Mith Tech in Bengaluru, and we deploy open-source commerce and ERP stacks on Hetzner for Indian businesses every month.

The cost comparison — Medusa + Hetzner vs Shopify

The headline argument for self-hosting Medusa is cost. But how much cheaper is it really, once you factor in managed databases, backups, and your order volume?

The calculation does not include developer time. If you have a developer on the team, self-hosting is dramatically cheaper. If you are hiring a freelancer to manage deployments, add $500–$1,000/month in labour — at which point Shopify makes sense until you hit ~2,000 orders/month where the 2% transaction fee overtakes the developer cost.

Which server tier fits your store

Hetzner's CAX line uses Ampere Altra ARM processors. They are cheaper per vCPU than x86, but you need ARM64-compatible Docker images. Medusa's official image supports multi-arch. The only catch is GitHub #16011 — medusa db:migrate can deadlock on ARM64 Linux. If you hit this, run the initial migration on an x86 instance (CX-series), then switch the running workload to ARM.

The production issues that break deployments

Admin login fails in production (GitHub #11769)

This is the most reported Medusa deployment bug — 33 comments, 6 reactions. The admin panel loads, you enter credentials, and nothing happens. No error, no redirect, no feedback.

The root cause is ADMIN_CORS. In development, Medusa runs on localhost:9000 and the admin is on localhost:9000/app — same origin, no CORS issue. In production, if you access the admin via https://admin.your-store.com but ADMIN_CORS is set to https://api.your-store.com, the browser blocks the login request silently.

The fix: set ADMIN_CORS to the origin your admin panel is served from. If the admin is on the same domain as the API (https://api.your-store.com/app), set it to https://api.your-store.com. If you host the admin separately, set it to that domain.

Build crashes on point releases (GitHub #14474)

Medusa's dependency tree is large — a transitive zod version mismatch (GitHub #12933, 47 comments, 7 reactions) broke fresh installs across many environments with Package subpath './v3' is not defined by 'exports'. The fix is to pin your lockfile and test upgrades on staging before applying to production.

In your Dockerfile, use npm ci --omit=dev (not npm install) to install from the lockfile deterministically. Never run npm install in a production Docker build — it resolves versions dynamically and can pull a broken transitive dependency.

Workflow engine must be Redis

Medusa v2's workflow engine defaults to in-memory mode. This means workflow state (including completeCartWorkflow, which transitions a cart to an order) lives in process memory. When your container restarts — for a deploy, a crash, or Coolify's health-check restart — all in-flight workflows are lost. Orders get stuck in a "completing" state with no way to recover without manual database intervention.

Switch to the Redis workflow engine in medusa-config.ts. This requires a Redis instance (already in the docker-compose) and stores workflow state persistently.

The deployment — step by step

# docker-compose.yml for Medusa v2 on Hetzner/Coolify
version: "3.8"

services:
  medusa:
    build:
      context: .
      dockerfile: Dockerfile
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://medusa:secret@db:5432/medusa?sslmode=disable
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=${JWT_SECRET}
      - COOKIE_SECRET=${COOKIE_SECRET}
      - STORE_CORS=https://your-storefront.com
      - ADMIN_CORS=https://admin.your-store.com
      - AUTH_CORS=https://admin.your-store.com
    ports:
      - "9000:9000"
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: medusa
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: medusa
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U medusa"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --requirepass redissecret
    volumes:
      - redisdata:/data
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "redissecret", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  pgdata:
  redisdata:

Production checklist

What to know before you commit

You own the uptime. Shopify's SLA is 99.99%. Your Hetzner server's SLA is 99.9% — and that covers hardware, not your application. If Medusa crashes at 2am, you are the oncall. Coolify's health checks and auto-restart help, but they are not a substitute for monitoring. Set up uptime monitoring on the /health endpoint at minimum.

ARM64 compatibility. Most official Docker images (Node, PostgreSQL, Redis) support ARM64. Some community Medusa plugins only publish x86 images. Check your dependencies before committing to an ARM server. If any plugin is x86-only, use a CX-series (x86) server instead — pricing is similar.

Backup strategy. Hetzner's managed PostgreSQL includes daily backups with 7-day retention. If you self-host PostgreSQL, set up a pg_dump cron job to an S3-compatible bucket (Hetzner Object Storage is €0.005/GB/month). Medusa stores product images in the filesystem or S3 — back those up too.

Security patching. Hetzner does not patch your server OS — you do. Run apt update && apt upgrade regularly (or enable unattended-upgrades for security patches). Docker images should be rebuilt monthly to pick up base-image security fixes. The 15 HIGH-severity CVEs in transitive dependencies (GitHub #14993) are your responsibility to override in package.json.

Medusa on Hetzner with Coolify runs for under $20/month and gives you full control over every line of code in your commerce stack. The trade-off is operational responsibility — you own the uptime, the backups, and the security patches. If you have a developer who can manage Docker containers, that trade-off is worth it from day one. If you do not, start on Shopify and migrate when revenue justifies the engineering time.