Kestra vs n8n vs Windmill (2026)

The Workflow Automation Pricing Problem

Zapier charges $20/month for 750 tasks, $49/month for 2,000 tasks, $69/month for multi-step workflows. For data engineering teams, Make (formerly Integromat) charges $9-29/month with scenario limits. At any meaningful automation volume, costs compound quickly.

Open source workflow automation tools flip this model: self-host once, run unlimited automations for the cost of your server.

Three tools cover different points on the developer spectrum: n8n for teams wanting a visual no-code/low-code builder with 400+ integrations, Kestra for data engineers who prefer declarative YAML orchestration, and Windmill for developers who want to write actual code (Python, TypeScript, Go) and compose it into workflows.

TL;DR

• n8n (174K+ stars): Best for teams that want visual workflow building with pre-built integrations. Closest to Zapier/Make in UX. Source-available (not fully open source). Massive community.
• Kestra (26K+ stars, Apache 2.0): Best for data engineers and complex orchestration. Declarative YAML workflows, 600+ plugins, event-driven architecture. True open source.
• Windmill (15K+ stars, AGPL-3.0): Best for developers who want to write code. Scripts in Python/TypeScript/Go compose into workflows. Also serves as an internal app builder.

Quick Comparison

Feature	n8n	Kestra	Windmill
GitHub Stars	174K+	26K+	15K+
Approach	Visual low-code	Declarative YAML	Code-first
Languages	JavaScript	Any (via plugins)	Python, TypeScript, Go, Bash
Pre-built integrations	400+	600+ plugins	Growing
Visual builder	Excellent	Yes	Yes
Data pipeline support	Limited	Excellent	Good
Internal app builder	Limited	No	Yes
Event-driven triggers	Yes	Yes	Yes
Git integration	Yes	Yes	Yes
Kubernetes ready	Yes	Yes	Yes
Open source license	Sustainable Use	Apache 2.0	AGPL-3.0

License note: n8n uses a "Sustainable Use License" — self-hosting is permitted but usage restrictions apply for commercial products embedding n8n. Kestra (Apache 2.0) and Windmill (AGPL-3.0) are true open source. Check licenses before building a commercial product on top of them.

n8n — Best Visual Workflow Builder

n8n (174K+ GitHub stars) is the most widely deployed self-hosted workflow automation tool. Its node-based visual editor connects services through a drag-and-drop interface — familiar territory for anyone who's used Zapier or Make.

What Makes It Stand Out

400+ integrations (nodes): n8n ships with pre-built connectors for Google Workspace, Slack, GitHub, Salesforce, HubSpot, databases, HTTP requests, webhooks, and hundreds of other services. Most Zapier/Make workflows can be replicated in n8n without writing code.

Visual workflow canvas: Build workflows by connecting nodes visually. See data flow from trigger to action, branch on conditions, loop over lists, and merge paths. Non-technical team members can build and modify workflows after an initial setup.

JavaScript code nodes: When pre-built nodes don't cover your use case, write JavaScript directly in a code node. Access the full Node.js ecosystem via npm packages.

Webhook triggers: Expose workflows as HTTP endpoints. External services can trigger workflows via webhook — Stripe payment webhook → create invoice record → send Slack notification.

AI agent nodes: n8n has integrated AI nodes for OpenAI, Anthropic, and other LLM providers. Build AI-assisted workflows without separate orchestration.

n8n Cloud vs self-hosted: n8n Cloud starts at $24/month for 2,500 workflow executions. Self-hosted is free with no execution limits.

Self-Hosting n8n

docker run -d \
  --name n8n \
  -p 5678:5678 \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD=yourpassword \
  -v n8n_data:/home/node/.n8n \
  n8nio/n8n

For production with PostgreSQL:

services:
  n8n:
    image: n8nio/n8n
    ports:
      - "5678:5678"
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: n8n
      N8N_ENCRYPTION_KEY: your-encryption-key
    volumes:
      - n8n_data:/home/node/.n8n

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: n8n
    volumes:
      - pg_data:/var/lib/postgresql/data

Limitations

• "Sustainable Use License" — not fully open source; review before embedding in commercial products
• JavaScript only for code nodes (no Python, Go, etc.)
• Less suited for data engineering and complex pipeline orchestration
• Performance at very high volume requires horizontal scaling

Best for: Teams migrating from Zapier/Make, non-technical teams who need visual workflow building, and integration-heavy automation workflows.

Kestra — Best for Data Engineering and Complex Orchestration

Kestra (26K+ GitHub stars, Apache 2.0) approaches automation differently from n8n. Rather than a visual node editor, Kestra uses declarative YAML configuration files — the same philosophy as infrastructure-as-code tools like Terraform.

This makes Kestra excellent for data engineers who want version-controlled, reviewable workflow definitions and complex orchestration patterns.

What Makes It Stand Out

YAML-first workflows: Every Kestra workflow is a YAML file. Workflows live in your Git repository alongside your application code — version controlled, reviewable via pull requests, and deployable via CI/CD pipelines.

id: data-pipeline
namespace: analytics

tasks:
  - id: extract
    type: io.kestra.plugin.jdbc.postgresql.Query
    url: "{{ secret('DB_URL') }}"
    sql: SELECT * FROM events WHERE date = '{{ trigger.date }}'

  - id: transform
    type: io.kestra.plugin.scripts.python.Script
    script: |
      import pandas as pd
      df = pd.read_json('{{ outputs.extract.uri }}')
      df['processed'] = True
      df.to_json('{{ outputFiles.result }}')

  - id: load
    type: io.kestra.plugin.gcp.bigquery.Load
    from: "{{ outputs.transform.outputFiles.result }}"
    table: my_dataset.processed_events

600+ plugins: Kestra's plugin library covers databases (PostgreSQL, MySQL, BigQuery, Snowflake, Redshift), cloud storage (S3, GCS, Azure Blob), APIs, scripts (Python, R, Julia, Bash), messaging (Kafka, Pulsar), and ML tools.

Event-driven triggers: React to file arrivals in S3, messages in Kafka, webhooks, database changes, or time schedules. Complex trigger logic with conditions and filters.

Parallel task execution: Run tasks in parallel with configurable concurrency limits. Fan-out to multiple downstream tasks, wait for all to complete before proceeding.

Backfills: Re-run historical workflow executions for a date range — essential for data pipeline recovery and historical data processing.

Namespaces: Organize workflows into namespaces with separate access controls. Keep analytics, ML, and operations workflows separated.

Built-in code editor: Kestra's UI includes an editor with YAML syntax highlighting and validation. Build and test workflows from the browser without a local development environment.

Self-Hosting Kestra

services:
  kestra:
    image: kestra/kestra:latest
    pull_policy: always
    entrypoint: /bin/bash
    command: -c 'exec /app/kestra server standalone'
    volumes:
      - kestra-data:/app/storage
      - /var/run/docker.sock:/var/run/docker.sock
      - /tmp/kestra-wd:/tmp/kestra-wd
    environment:
      KESTRA_CONFIGURATION: |
        datasources:
          postgres:
            url: jdbc:postgresql://postgres:5432/kestra
            username: kestra
            password: k3str4
        kestra:
          server:
            basic-auth:
              enabled: false
          repository:
            type: postgres
          storage:
            type: local
            local:
              base-path: "/app/storage"
    ports:
      - "8080:8080"
      - "8081:8081"

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: kestra
      POSTGRES_USER: kestra
      POSTGRES_PASSWORD: k3str4
    volumes:
      - pg_data:/var/lib/postgresql/data

Kestra also deploys on Kubernetes via Helm chart for production high-availability deployments.

Limitations

• YAML-first approach has a learning curve for non-developers
• Less suitable for simple point-and-click automation
• Fewer pre-built UI integrations than n8n
• Smaller community than n8n (though growing rapidly)

Best for: Data engineers, platform teams, and anyone who wants Git-versioned workflow definitions and complex orchestration with multi-language script support.

Windmill — Best for Developer-Centric Automation

Windmill (15K+ GitHub stars, AGPL-3.0) sits at the intersection of script management, workflow orchestration, and internal app building. It's less about connecting SaaS services and more about developers writing scripts that compose into automated workflows.

What Makes It Stand Out

Multi-language scripts: Write workflow steps in Python, TypeScript, Go, or Bash. Each script is a self-contained function with typed inputs and outputs. Windmill generates a UI form from your function signature — share the script as an internal tool immediately.

Script composition: Connect scripts into workflows. The output of one script becomes the input of the next. Visual flow editor for composition, code editor for each step.

Internal app builder: Beyond automation, Windmill builds internal CRUD apps. Connect scripts to a UI builder — tables, forms, buttons — and deploy as internal tools. Similar to Retool or AppSmith but built around your scripts.

Hub of community scripts: Windmill Hub contains pre-built scripts for common tasks — database queries, API calls, data transformations. Import and modify community scripts rather than writing from scratch.

Per-script versioning: Each script in Windmill has a version history. Roll back a specific automation step to a previous version without affecting the rest of the workflow.

Resource management: Define resources (database connections, API credentials) centrally and reference them across scripts. No credential duplication across workflows.

Webhook and schedule triggers: Expose workflows as HTTP endpoints or schedule them with cron-like syntax.

Self-Hosting Windmill

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_DB: windmill
      POSTGRES_USER: windmill
      POSTGRES_PASSWORD: windmill
    volumes:
      - db_data:/var/lib/postgresql/data

  windmill_server:
    image: ghcr.io/windmill-labs/windmill:main
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: postgres://windmill:windmill@db:5432/windmill
      BASE_URL: https://windmill.yourdomain.com
      RUST_LOG: info
    depends_on:
      - db

  windmill_worker:
    image: ghcr.io/windmill-labs/windmill:main
    environment:
      DATABASE_URL: postgres://windmill:windmill@db:5432/windmill
      MODE: worker
      WORKER_GROUP: default
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    depends_on:
      - db

Windmill separates server and worker processes — run multiple workers for parallel execution capacity.

Windmill Cloud: Managed cloud at $10/user/month. Self-hosted is free (AGPL-3.0 — if you're embedding in a commercial SaaS, review license requirements).

Limitations

• Smaller integration library than n8n
• Less suited for non-technical users
• AGPL-3.0 license has implications for commercial use
• Less mature than n8n for complex integration workflows

Best for: Developer teams who want to write actual code (Python/TypeScript/Go) and compose it into automated workflows, plus build internal tools from the same codebase.

Choosing Between Them

Scenario	Recommended
Migrate from Zapier/Make	n8n
Non-technical team	n8n
400+ pre-built integrations needed	n8n
Data engineering pipelines	Kestra
Git-versioned workflow definitions	Kestra
Complex event-driven orchestration	Kestra
Run scripts in Python/TypeScript/Go	Windmill
Build internal apps alongside automation	Windmill
Full Apache 2.0 open source required	Kestra
Maximum GitHub community support	n8n

Cost Comparison

Commercial Automation Tools (Annual)

Tool	Tier	Annual
Zapier	Professional (2K tasks)	$588
Make	Core (10K ops)	$108
n8n Cloud	Pro (10K executions)	$288

Self-Hosted (Annual)

Tool	Server (Hetzner CPX21)	Annual
n8n	$6.50/mo	$78
Kestra	$6.50/mo (+ CPX31 for heavy workloads)	$78-120
Windmill	$6.50/mo	$78

All three tools run comfortably on a $6.50/month Hetzner server for small-to-medium automation workloads. Scale up as execution volume grows.

Handling Failures and Retries: The Operational Difference

How each tool handles failures in production is one of the most important factors when choosing a workflow automation platform — and it's rarely mentioned in feature comparisons.

n8n's approach: By default, n8n stops execution at the first failed node and marks the workflow as failed. You can configure retry logic per-node (up to 10 retries with configurable backoff), but the error handling is workflow-level. For SaaS integration workflows where API failures are common (rate limits, temporary outages), n8n's Error Workflow feature lets you define a separate workflow that triggers when the main one fails — useful for sending alerts or triggering cleanup steps.

Kestra's approach: Kestra has the most mature retry and error handling model. Each task within a flow can define its own retry strategy (number of retries, retry delay, retry behavior on specific error types). Flow-level error handling supports onFailure tasks that run when any task fails — analogous to n8n's Error Workflow but defined within the flow YAML itself. For data engineering use cases where partial re-runs are expensive, Kestra's checkpoint and restart capabilities let you resume a failed flow from the last successful task rather than re-running from the beginning.

Windmill's approach: Since Windmill workflows are composed of individual scripts, failure isolation is more granular. A failed Python step doesn't take down the other steps unless they depend on its output. This composability means debugging is simpler — run the failing script in isolation, fix it, redeploy it. Windmill's built-in execution history shows per-step input/output for every run, which makes diagnosing intermittent failures significantly faster than examining n8n's execution logs.

For teams already using n8n, the self-host n8n guide covers production tuning for reliability — queue configuration, webhook reliability, and scaling workers. The best open source automation tools 2026 covers the broader automation landscape including Activepieces and Temporal for teams with more demanding requirements. For teams combining workflow automation with AI pipelines — using n8n or Kestra to orchestrate LLM calls, RAG queries, and data transforms — the best open source AI developer tools 2026 covers the models, embeddings, and inference infrastructure that underpin these hybrid workflows.

Find Your Automation Tool

Browse all workflow automation tools on OSSAlt — compare n8n, Kestra, Windmill, Prefect, and every other open source automation platform with deployment guides and feature comparisons.

See open source alternatives to n8n on OSSAlt.