n8n Review: Open-Source Workflow Automation for Technical Teams (2026)

import ProsConsCard from ’../../components/ProsConsCard.astro’;

n8n (pronounced “n-eight-n”) is a source-available workflow automation tool that takes a developer-first approach. The key differentiator: you can run it on your own server for free, write JavaScript or Python inside workflows, and build AI agent systems with native LangChain support.

Self-Hosting vs. Cloud

This is the defining decision with n8n:

Self-hosted (free):

# Run with Docker Compose
version: "3"
services:
  n8n:
    image: docker.n8nio/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - WEBHOOK_URL=https://n8n.yourdomain.com/
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data

Cloud hosting:

• n8n Cloud (paid, fully managed)
• Railway, Render, Fly.io (third-party hosting, some free tiers)
• AWS/GCP/Azure (self-managed, more control)

Cost comparison at 100,000 workflow executions/month:

• n8n self-hosted: ~$5-20/month (server cost only)
• n8n Cloud Pro: $50/month
• Make: ~$59/month
• Zapier Professional: ~$200-400/month

---

Code Nodes: The Killer Feature

n8n’s ability to write custom JavaScript or Python inside workflows is what separates it from Zapier and Make for developers:

JavaScript code node:

// Transform and process incoming webhook data
const orders = $input.all();

// Complex data transformation
const processedOrders = orders.map(order => {
  const items = order.json.line_items;
  
  // Calculate metrics
  const totalItems = items.reduce((sum, item) => sum + item.quantity, 0);
  const highValueItems = items.filter(item => item.price > 100);
  
  // Format for downstream systems
  return {
    orderId: order.json.id,
    customerEmail: order.json.email,
    totalItems,
    totalValue: order.json.total_price,
    hasHighValueItems: highValueItems.length > 0,
    highValueItemNames: highValueItems.map(i => i.title).join(', '),
    // Custom business logic
    discountEligible: totalItems >= 5 && order.json.total_price >= 200,
    fulfillmentPriority: highValueItems.length > 0 ? 'HIGH' : 'NORMAL',
    formattedDate: new Date(order.json.created_at).toLocaleDateString('en-US'),
  };
});

return processedOrders.map(item => ({ json: item }));

Python code node:

# Data analysis or ML inference inside a workflow
import json
import statistics

orders = $input.all()

# Statistical analysis
order_values = [float(o['json']['total_price']) for o in orders]
analysis = {
    'count': len(order_values),
    'mean': statistics.mean(order_values),
    'median': statistics.median(order_values),
    'stdev': statistics.stdev(order_values) if len(order_values) > 1 else 0,
    'min': min(order_values),
    'max': max(order_values),
    'total': sum(order_values),
    'above_average': sum(1 for v in order_values if v > statistics.mean(order_values)),
}

return [{'json': analysis}]

This is simply not possible in Zapier or Make without external services.

---

AI Agent Workflows

n8n has first-class AI agent support with LangChain integration:

AI Agent node example:

Workflow: Customer support AI agent

Trigger: New support ticket via webhook

AI Agent node:
├── System prompt: "You are a helpful customer support agent for [Company]. 
│                   Answer questions about orders, products, and policies.
│                   If you can't resolve an issue, escalate to human support."
│
├── Tools (what the agent can do):
│   ├── HTTP Request tool: Query orders API
│   │   → GET /api/orders/{order_id}
│   ├── HTTP Request tool: Check tracking status
│   │   → GET /api/tracking/{tracking_number}
│   └── Email tool: Send customer email
│
├── LLM: OpenAI GPT-4o (or Anthropic Claude)
│
└── Memory: Window buffer (last 10 messages for context)

Output → If "escalate" detected → Create Zendesk ticket + Slack alert
Output → Otherwise → Send AI-generated reply to customer

RAG (Retrieval-Augmented Generation) workflow:

Workflow: AI search over documentation

Trigger: Chat widget message

1. OpenAI Embeddings: Convert question to vector
2. Pinecone: Retrieve similar documents (top 5)
3. Code Node: Format retrieved docs as context
4. OpenAI: Generate answer using retrieved context
5. Webhook Response: Return answer to chat widget

---

Workflow Examples

Database sync automation:

Workflow: Sync Postgres → Airtable daily

1. Cron Trigger: Every day at 6am
2. Postgres: SELECT * FROM customers WHERE updated_at > NOW() - INTERVAL '1 day'
3. Code Node: Transform Postgres schema to Airtable format
4. Split in Batches: Process 100 records at a time
5. Airtable: Upsert each batch
6. Code Node: Count successes and failures
7. Slack: Daily sync report

Web scraping pipeline:

Workflow: Competitor price monitoring

1. Cron Trigger: Every 4 hours
2. Loop: For each competitor URL in config
   a. HTTP Request: Fetch competitor pricing page
   b. Code Node (Cheerio): Parse HTML, extract prices
   c. If price changed: Update Airtable record
   d. If price dropped below threshold: Slack alert
3. Google Sheets: Log all price changes

---

n8n vs. Make vs. Zapier

Feature	n8n	Make	Zapier
Open source	Yes	No	No
Self-hosted	Yes (free)	No	No
Code nodes	Yes (JS + Python)	No	No
AI agents	Native	Via modules	Via modules
Integrations	600+	1,000+	5,000+
Visual builder	Good	Excellent	Good (list-based)
Learning curve	High (dev-friendly)	Medium	Low
Free tier	Unlimited (self-hosted)	1,000 ops	100 tasks
Cloud pricing	$20-50/month	$9-29/month	$20-400/month

---

Pricing

Plan	Price	Executions
Self-hosted	Free	Unlimited
Cloud Starter	$20/month	2,500 executions
Cloud Pro	$50/month	10,000 executions
Enterprise	Custom	Unlimited + support

Note: “Executions” = one complete workflow run. Unlike Make’s per-operation pricing, n8n counts entire workflow runs.

---

Who n8n Is For

Best for:

• Developers and technical teams wanting code flexibility in automations
• Teams with data privacy requirements (self-hosted, data stays local)
• High-volume use cases where per-operation pricing is prohibitive
• AI agent workflows requiring custom tool integrations
• Teams building internal tools that need automation as a component
• Startups minimizing SaaS costs

Not ideal for:

• Non-technical users (setup and debugging require technical knowledge)
• Teams needing maximum app integration breadth (Zapier has 5,000+)
• Anyone who needs polished UX and enterprise support SLA

---

Bottom Line

n8n has earned its position as the go-to automation tool for technical teams. The code nodes alone make it qualitatively different from Make and Zapier — you’re not constrained to what the platform’s modules support. The self-hosted option’s unlimited free tier is genuinely free, not “free with asterisks.” For non-developers, n8n’s complexity is real friction. For developers who’ve fought with Zapier’s limitations, n8n feels like finally having the right tool. Rate 4.3/5.