What You'll Need
- n8n Cloud or self-hosted n8n
- Hetzner VPS or Contabo VPS for hosting
- DigitalOcean as alternative
- A spreadsheet to track your workflow costs (Google Sheets works fine)
Table of Contents
- The 2026 Pricing Landscape
- Windmill: Open-Source Simplicity
- n8n: Enterprise-Grade Flexibility
- Make: The No-Code Premium Play
- Head-to-Head Cost Breakdown
- Which Platform Wins for Your Use Case
- Getting Started
The 2026 Pricing Landscape
I've been building and deploying workflow automation platforms for three years now, and I can tell you with confidence: pricing changed significantly in 2025 and continues to shift into 2026. When you're choosing between Windmill, n8n, and Make, you're not just picking a tool—you're betting on a pricing model that could swing your budget by 40–60% annually.
Let me walk you through exactly what each platform costs in 2026, how they calculate fees, and crucially, where the hidden charges lurk.
The bigger picture? If you're running complex API-heavy workflows, understanding how these platforms tier their usage can be the difference between a $500/month bill and a $5,000 one. That's why when I'm evaluating platforms, I also look at adjacent solutions like Airflow vs n8n vs Temporal for API workflows to understand the full competitive landscape.
Windmill: Open-Source Simplicity
Windmill is the dark horse here. It's genuinely open-source, which immediately changes the entire pricing equation.
Self-Hosted (No Monthly Cost)
If you run Windmill self-hosted on your own infrastructure—say, a Contabo VPS with 4GB RAM for $3.99/month—your actual software cost is zero. You only pay for compute.
Here's a realistic self-hosted setup on Contabo:
version: '3.8'
services:
windmill:
image: ghcr.io/windmill-labs/windmill:latest
ports:
- "80:8000"
environment:
- DATABASE_URL=postgres://windmill:windmill@postgres:5432/windmill
- MODE=worker
- WORKER_THREADS=4
- RUST_LOG=info
- NUM_WORKERS=3
- DENO_PATH=/denots
volumes:
- ./worker_logs:/var/lib/windmill/logs
depends_on:
- postgres
restart: always
postgres:
image: postgres:15-alpine
environment:
- POSTGRES_USER=windmill
- POSTGRES_PASSWORD=windmill
- POSTGRES_DB=windmill
volumes:
- postgres_data:/var/lib/postgresql/data
restart: always
nginx:
image: nginx:alpine
ports:
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
- ./ssl:/etc/nginx/ssl:ro
depends_on:
- windmill
restart: always
volumes:
postgres_data:
networks:
default:
driver: bridge
Deploy this with Docker Compose, and you've got a fully functional Windmill instance. Running costs: roughly $4/month for the VPS.
Windmill Cloud (Managed)
If you prefer not to manage infrastructure, Windmill Cloud starts at $0 free tier with 10,000 executions/month, then $25/month for their Pro tier (100,000 executions/month), climbing to $200/month for Enterprise.
Key advantage: Windmill doesn't charge per "automation" or "task"—only execution count. If you have 100 idle workflows, they cost nothing. That's fundamentally different from Make's model.
n8n: Enterprise-Grade Flexibility
n8n Cloud is where things get interesting for mid-market and enterprise deployments.
n8n Cloud Pricing (2026)
- Free: 100 executions/month (basically a sandbox)
- Pro: $20/month (10,000 executions/month per user, 2 users)
- Business: $100/month (500,000 executions/month per user, unlimited users)
- Enterprise: Custom pricing (dedicated support, SSO, webhook queues)
But here's what matters: if you're running 2 million executions/month, you're looking at $240/month (Business tier) or more if you add team members.
Self-Hosted n8n (My Preference)
I typically recommend self-hosting n8n for serious automation work. Here's a Docker Compose setup on a Hetzner VPS (CPX11, €5.83/month with unlimited traffic):
version: '3.8'
services:
n8n:
image: n8nio/n8n:latest
ports:
- "80:5678"
environment:
- NODE_ENV=production
- WEBHOOK_URL=https://yourdomain.com
- GENERIC_FUNCTION_ALLOW_BUILTIN=true
- N8N_LOG_LEVEL=info
- DB_TYPE=postgresdb
- DB_POSTGRESDB_HOST=postgres
- DB_POSTGRESDB_PORT=5432
- DB_POSTGRESDB_DATABASE=n8n
- DB_POSTGRESDB_USER=n8n
- DB_POSTGRESDB_PASSWORD=securepassword123
- N8N_ENCRYPTION_KEY=generated_encryption_key_here
- EXECUTIONS_TIMEOUT=600
- EXECUTIONS_TIMEOUT_MAX=3600
- N8N_METRICS=true
- QUEUE_TYPE=redis
- QUEUE_BULL_REDIS_HOST=redis
- QUEUE_BULL_REDIS_PORT=6379
volumes:
- n8n_data:/home/node/.n8n
depends_on:
- postgres
- redis
restart: always
networks:
- n8n_network
postgres:
image: postgres:15-alpine
environment:
- POSTGRES_USER=n8n
- POSTGRES_PASSWORD=securepassword123
- POSTGRES_DB=n8n
volumes:
- postgres_data:/var/lib/postgresql/data
restart: always
networks:
- n8n_network
redis:
image: redis:7-alpine
restart: always
networks:
- n8n_network
nginx:
image: nginx:alpine
ports:
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
- ./ssl_certs:/etc/nginx/ssl:ro
depends_on:
- n8n
restart: always
networks:
- n8n_network
volumes:
n8n_data:
postgres_data:
networks:
n8n_network:
driver: bridge
This runs on Hetzner with no monthly software license. Total cost: €5.83/month for the server.
n8n Enterprise
If you need enterprise features (dedicated instance, priority support, custom nodes), n8n offers white-label solutions starting around $500/month for serious deployments.
💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.
Make: The No-Code Premium Play
Make (formerly Integromat) is the platform for teams that don't want to think about infrastructure at all. But it costs.
Make Pricing Structure (2026)
Make charges per "operation"—each step in your workflow counts as one operation.
- Free: 1,000 operations/month
- Core: $9.99/month (10,000 operations)
- Pro: $19/month (100,000 operations)
- Business: $55/month (300,000 operations)
- Enterprise: $490+/month (1 million operations)
Here's the catch: One workflow that loops through 1,000 items and performs 5 actions per item = 5,000 operations in one execution. Scale that to daily runs, and you're burning through your quota fast.
Make Real-World Example
Let's say you're syncing 50,000 CRM contacts weekly to a database, processing each contact through 3 operations:
50,000 contacts × 3 operations × 4 syncs/month = 600,000 operations/month
Cost: Pro tier ($19/month) insufficient → Business tier ($55/month)
If that contact base grows to 200,000, you're looking at 2.4 million operations/month, pushing you into Enterprise territory at $490+/month.
This is where platforms like Temporal vs Zapier vs n8n: Enterprise Workflow Costs matter—because Make's operation counting becomes punishing at scale.
Head-to-Head Cost Breakdown
Let me give you concrete scenarios for a business running different workload patterns:
Scenario 1: Light Automation (10,000 executions/month)
| Platform | Monthly Cost | Notes |
|---|---|---|
| Windmill Cloud | $25 | Pro tier covers this easily |
| n8n Cloud | $20 | Pro tier, single user |
| Make | $9.99 | Core tier if lean workflows |
| n8n Self-Hosted | $5.83 (Hetzner) | Lowest total cost |
| Windmill Self-Hosted | $3.99 (Contabo) | True minimum cost |
Winner: Windmill Self-Hosted
Scenario 2: Medium Automation (500,000 executions/month)
| Platform | Monthly Cost | Notes |
|---|---|---|
| Windmill Cloud | $200 | Enterprise tier |
| n8n Cloud | $100 | Business tier |
| Make | $55 | Business tier, but depends on operation count |
| n8n Self-Hosted | $5.83 + resource scaling | Likely $15-25 with heavier compute |
| Windmill Self-Hosted | $10-15 | Scales efficiently with execution count |
Winner: n8n Self-Hosted or Windmill Self-Hosted
Scenario 3: High-Volume (2+ million executions/month)
| Platform | Monthly Cost | Notes |
|---|---|---|
| Windmill Cloud | $500+ | Custom Enterprise plan |
| n8n Cloud | $240+ | Business tier for multiple team members |
| Make | $490+ | Enterprise tier minimum, operations spike |
| n8n Self-Hosted | $50-100 | Dedicated server, database optimization |
| Windmill Self-Hosted | $30-60 | Most cost-effective at scale |
Winner: Windmill Self-Hosted
Which Platform Wins for Your Use Case
Choose Windmill If:
- You're cost-conscious and willing to manage infrastructure
- You run millions of simple executions (loops, data transforms)
- You want true open
Originally published on Automation Insider.
Top comments (0)