<!-- OSSAlt AI-readable guide source -->
<!-- Canonical: https://ossalt.com/guides/kestra-vs-n8n-vs-windmill-2026 -->
<!-- Raw Markdown: https://ossalt.com/guides/kestra-vs-n8n-vs-windmill-2026/raw.md -->
<!-- Source path: content/guides/kestra-vs-n8n-vs-windmill-2026.mdx -->

---
og_image: "/images/guides/kestra-vs-n8n-vs-windmill-2026.webp"
title: Kestra vs n8n vs Windmill (2026)
description: "Zapier charges $20-69/month for 750-2,000 tasks. These self-hosted workflow orchestration tools give you unlimited automation runs with full code flexibility."
date: "2026-03-08"
author: "OSSAlt Team"
tags: ["kestra", "n8n", "windmill", "workflow-automation", "orchestration", "open-source", "self-hosted", "zapier", "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

```bash
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:

```yaml
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.

```yaml
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

```yaml
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

```yaml
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](/guides/self-host-n8n-zapier-2026) covers production tuning for reliability — queue configuration, webhook reliability, and scaling workers. The [best open source automation tools 2026](/guides/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](/guides/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](https://ossalt.com) — 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](https://www.ossalt.com/alternatives/n8n).*