ORCHESTRATION • CLUSTER B

n8n vs Temporal vs Windmill: The Orchestration Decision

Three engines, three execution contracts. A decision framework by failure mode, verified Cloud pricing math, and the migration path between them.

By Alex, Principal AI Infrastructure Architect | Updated September 2026 | 14 min read

n8n vs Temporal vs Windmill: The Orchestration Decision

Pick by failure mode, not by feature grid. Here is the framework we use.

THE VERDICT

These three tools are not competitors so much as three different answers to one question: what happens when a step fails mid-run? n8n answers with an integration graph — visual, node-based, with the deepest connector library for SaaS work. Temporal answers with durable execution — your code replays from event history until it completes, which is why OpenAI, Netflix, and NVIDIA run it. Windmill answers with checkpoints — plain Python or TypeScript scripts that persist results instead of replaying commands, no determinism rules, one Postgres. Choose by your failure blast radius: integration sprawl → n8n; money-moving multi-day logic → Temporal; internal tooling and fan-out jobs → Windmill.

TL;DR:

  • n8n — fair-code visual automation, 400+ integrations, queue mode with Redis workers. Best when the work is connecting SaaS products, not writing business logic. Weakness: complex in-process logic gets awkward in nodes.
  • Temporal — Workflows-as-Code, MIT-licensed, 7 official SDKs. Event-sourced: every step is recorded, workflows replay to recover. The only choice for multi-day sagas, payments, and anything auditable. Weakness: a determinism contract on your workflow code, a 4-service cluster to run, and Cloud pricing that starts at $100/month.
  • Windmill — AGPLv3, scripts in Python/TypeScript/Go/Bash become flows and auto-generated UIs on a single Postgres. Checkpoints in ~0.5ms per step, ~50ms job overhead, and no determinism rules. Weakness: a smaller primitive surface, and the audience is engineers — no visual-first story for non-developers.

"n8n orchestrates integrations. Temporal orchestrates code that must not lose state. Windmill orchestrates scripts your whole team can ship. Misdiagnose which one you need, and you will pay for it in either engineering time or license fees — usually both."

Table of Contents

Three Engines, Three Contracts

The feature grids look similar — all three run workflows, retry steps, and scale workers. The contracts underneath are incompatible, and that is where the decision actually lives. Read charitably, all three are attempts at the same Zero-Glue Theorem move — eliminating unstable middleware by enforcing native protocol boundaries — they simply draw the boundary in different places: n8n at the integration edge, Temporal inside your own code, Windmill inside one Postgres.

Contract n8n Temporal Windmill
Authoring model Visual nodes + code nodes Workflows-as-Code (SDK) Scripts-as-code → flows
Failure recovery Node-level retries, error workflows Event-history replay from any failure Checkpoint resume (results, not events)
Determinism required No Yes — workflow code must be deterministic No — clock, randomness, I/O all fine
State backend SQLite / PostgreSQL (queue mode) + Redis Cassandra / PostgreSQL / MySQL + its 4 services Single PostgreSQL
License Fair-code (Sustainable Use License) MIT AGPLv3 core + proprietary Enterprise
Managed cloud n8n Cloud Temporal Cloud, from $100/mo Windmill Cloud
Non-developer story Strong (visual editor) None Partial (auto-generated UIs)

One framing note from Temporal itself, worth respecting: the project explicitly positions its category as Durable Execution — orchestration plus coordination plus human-in-the-loop plus agent reliability in one model — and describes "workflow orchestration tool" as a narrower framing. For this comparison, that claim is load-bearing: Temporal is not trying to be a better n8n, it is solving a different stratum of the problem.

Where n8n Wins: The Integration Graph

n8n's real moat is not the workflow engine — it is the connector library. Four hundred plus prebuilt integrations, credential management, and a visual canvas that lets an operations person assemble a lead-routing flow in an afternoon. When your orchestration problem is mostly "call these six APIs in the right order with the right retries," the engine underneath barely matters, and n8n's queue mode (covered in our queue mode blueprint) scales the execution side properly.

The contract breaks when the logic gets deep. Branch-heavy business rules, compensation logic, multi-day waits with human approval in the middle — all expressible in n8n, all awkward. Experienced operators hit this wall as "the 300-node workflow nobody dares edit." Version control and testing for visual workflows also lag what a code-native team expects.

Where Temporal Wins: State You Can Bet Money On

Temporal records every step of a workflow as an event, persists the history to its database, and — if a worker dies mid-run — replays the workflow code from the beginning against that history until it resumes exactly where it stopped. Retry policies are declared, not hand-coded: exponential backoff, per-activity timeouts, retries that can span months. Timers survive outages. The Saga pattern is literally try/catch around compensation activities.

The official docs are direct that this is Workflows-as-Code, not a no-code engine — you write workflows in one of 7 official SDKs (Go, Java, Python, TypeScript, .NET, PHP, Ruby, with Rust in preview). That is the price and the product: full control in exchange for a determinism contract. Workflow code cannot call the clock, generate random numbers, or perform I/O directly — those belong in Activities. Break determinism and replay breaks with it.

Self-hosting is free and MIT-licensed, but the server is a genuine distributed system (four internal services plus a database). Temporal Cloud exists for teams who would rather not run that: Essentials from $100/month, Business from $500/month with SAML SSO included, and action-metered pricing at $50 per million Actions with volume tiers down to $25 per million past 200 million.

Where Windmill Wins: Scripts Your Whole Team Ships

Windmill starts from a different primitive: a single file of Python, TypeScript, Go, Bash, or SQL. Its parameters auto-generate a UI. Chain files into flows and you have a workflow engine; wrap them in the low-code app builder and you have internal tooling — one platform, shared auth, secrets, and observability.

Architecturally it is the simplest of the three: a stateless Rust server, workers, and one PostgreSQL that is both state and queue. No four-service split, no separate message broker. The vendor's own comparison with Temporal names the mechanics precisely: Windmill's step() checkpoints results in roughly 0.5ms, job dispatch overhead is ~50ms, and because checkpoints store results rather than replaying commands, workflow code has no determinism contract — call Math.random(), read the clock, do whatever the language normally allows.

That vendor benchmark claim — "fastest self-hostable workflow engine" against Airflow, Prefect, and Temporal — is the vendor's own methodology, so treat it as a vendor benchmark, not an independent measurement. On the workload split, Windmill's own comparison page states the pattern: Temporal is faster on long sequential workflows (its History service lowers per-step overhead), Windmill is faster on parallel fan-out workloads. Independent numbers do not exist; run your own workload before betting either way.

The license needs a sentence of honesty: the core is AGPLv3 and genuinely self-hostable with no feature gating, while Enterprise features (SSO/SCIM, audit logs, Git sync, air-gapped support) live in a separate proprietary codebase sold with published per-seat and per-worker pricing.

The Decision Matrix

Stay on n8n when…
  • The work is connecting SaaS APIs — CRM, email, sheets, webhooks
  • Non-developers must own or edit the flows
  • Volume fits queue mode on one or two workers
  • Business logic fits in nodes without deep nesting
Move to Temporal when…
  • Steps move money, provision infrastructure, or touch ledgers
  • Workflows run for hours to weeks with human approval gates
  • Auditors ask "prove what executed" — event history is the answer
  • Your team lives in Go/Java/Python/TypeScript already
Pick Windmill when…
  • Internal ops tooling and data jobs outnumber customer-facing flows
  • Engineers want plain Python/TS, versioned in Git, no DSL
  • You want one Postgres, not a distributed cluster, on self-host
  • Auto-generated UIs can replace a separate Retool bill

The uncomfortable truth for teams hoping one tool covers everything: the overlap zone is small. A lead-routing flow that touches five SaaS APIs is n8n work even if Temporal could express it. A payment saga is Temporal work even if Windmill could checkpoint it. Teams that try to force one engine across all three strata usually end up running two anyway — the honest question is which two, and which one is the system of record.

Where Each One Fails

n8n: the un-editable mega-workflow

Complexity accumulates in the canvas. Past roughly a hundred nodes with nested branches, changes require archaeology, testing is manual, and code review does not apply. The failure is gradual: velocity drops until the team rewrites the flow as code somewhere else.

Temporal: determinism violations in production

A workflow that calls time.Now() or a non-deterministic library function passes every test, then breaks replay the first time a worker restarts mid-run. The SDKs ship detectors (Go's workflowcheck, the TS replayer), but the failure class is unique to the replay model and it surfaces at the worst time: recovery.

Windmill: the governance ceiling

What is in open source is real, but SSO, audit logs, and Git sync are Enterprise-edition items. A team that standardizes on Windmill CE and later needs those features is negotiating a contract, not flipping a config flag.

Temporal Cloud Cost Math (Verified Against the Official Pricing Page)

Temporal Cloud bills three things: a plan floor, Actions, and storage. From the official pricing page:

Item Official figure
Essentials plan $100/mo, includes 1M Actions, 1 GB active / 40 GB retained storage
Business plan $500/mo, includes 2.5M Actions, SAML SSO included
Actions (first 5M) $50 per million, volume tiers down to $25/M over 200M
Plan fee rule Greater of the plan fee or 5–10% of monthly usage
Storage Active $0.042/GBh; retained $0.00105/GBh
The budgeting trap: an "Action" is every billable operation — workflow start, each Activity completion, each timer fire, each heartbeat, each signal. A single business process routinely generates dozens of Actions. Estimate Actions per workflow run first, then multiply by run volume. Teams that estimate from workflow count get surprised invoices; this is the single most common Temporal budgeting error reported by operators.

The Actions Estimator

Temporal Cloud Actions Estimator

Actions per month600,000
Baseline usage cost$30
Plan that covers itEssentials ($100/mo floor)

Formula consistency check: 500 runs × 40 actions × 30 days = 600,000 Actions/month. At $50 per million that is $30 of usage — below the Essentials floor, so the bill is $100. Same numbers the calculator produces, by construction. Storage is extra and depends on your event-history sizes and retention window (up to 90 days on Cloud).

The Migration Timeline

1
Inventory by failure mode
Split the workflow estate into three buckets: SaaS integration glue, money-or-state-critical logic, and internal tooling. Each bucket has a natural landing zone — n8n, Temporal, Windmill respectively.
2
Port activity bodies, rewrite orchestration
The per-step logic (API calls, transforms) moves almost unchanged off any of the three platforms. The orchestration wrapper — node graph, SDK primitives, or flow YAML — is the part that gets rewritten. Budget accordingly.
3
Run one workflow in parallel for two weeks
Dual-run the highest-volume process on both engines and diff outcomes. This is the only reliable way to discover determinism violations (Temporal) or checkpoint edge cases (Windmill) before cutover.
4
Cut over by trigger, not by big bang
Flip webhook and schedule triggers one workflow at a time. In-flight runs finish on the old engine; new runs land on the new one. No migration window required.

Frequently Asked Questions

Download this guide’s assets

Get the orchestration decision framework PDF from this guide. Instant download — no email required.

Download the bundle →

Prefer it by email? Subscribe for the full library →

Is Temporal a replacement for n8n?
No — they solve different strata. n8n is an integration graph for SaaS-centric automation with a visual editor non-developers can use. Temporal is a durable-execution platform for code-defined business logic that must survive any failure with auditable state. Teams running both typically use n8n for integration glue and Temporal for the critical core.
Why does Temporal require deterministic workflow code?
Temporal recovers workflows by replaying the workflow function against its recorded event history. If the code makes different decisions on replay than it did originally (reading the clock, random values, direct I/O), the replay diverges and recovery breaks. Non-deterministic work belongs in Activities, which store their results in history instead.
Does Windmill have a determinism requirement like Temporal?
No. Windmill checkpoints results rather than replaying commands, so workflow code can read the clock, use randomness, and perform I/O normally. The trade-off is a smaller primitive surface — fewer built-in signals, queries, and search attributes than Temporal's event-sourced model.
What does Temporal Cloud actually cost per month?
The Essentials plan is $100/month including 1 million Actions; Business is $500/month including 2.5 million Actions with SAML SSO. Beyond included Actions, pricing starts at $50 per million with volume tiers down to $25 per million past 200 million, and the plan fee is the greater of the floor or 5–10% of usage. Storage is separate. Self-hosted Temporal is free under MIT.
Is Windmill really open source if it has an Enterprise edition?
The core is AGPLv3 and fully self-hostable with no feature gating or license server. Enterprise features (SAML/SCIM, audit logs, Git sync, air-gapped deployment) ship in a separate proprietary codebase with published per-seat and per-worker pricing. This is an open-core model — compare it to Temporal, whose MIT core is more permissive but whose governance features live only in the managed Cloud.
Which engine scales workers cheapest on self-hosted infrastructure?
Windmill has the smallest footprint: one Postgres plus stateless workers, with roughly 50ms dispatch overhead per job. n8n queue mode needs Redis plus PostgreSQL and is tuned in our queue mode blueprint. Temporal self-hosted is free under MIT but operates a multi-service cluster — the engineering cost is the real price, which is exactly the gap Temporal Cloud sells against.

Related Reads

This decision sits above the infrastructure layer covered elsewhere in the cluster — the queue mode docker-compose blueprint handles the n8n execution plane, the Postgres vs SQLite benchmark handles its state layer, and the webhook relay sizing guide handles its failure edge.

Related Cluster Intelligence

Engineering Transparency: Wenboom benchmarks and deploys enterprise architectures internally. Product links use clean router paths (/links/[tool]). If you deploy through them, we may earn an affiliate commission at $0 added cost to you. All performance figures in this article come from internal testing under the configurations documented here; results vary by workload, scale, and environment. We disclose limitations and failure modes wherever they exist. Authored by Alex, Principal AI Infrastructure Architect at Wenboom. See our Terms of Service for the full disclaimer.