Windmill

Positioning: the internal-tools platform that assumes you write code

Windmill takes a stance that most workflow tools hedge on: the unit of automation is a script, not a flowchart. You write functions in Python, TypeScript, Go, Bash, SQL, GraphQL, PowerShell or Rust, and Windmill turns each one into three things at once — a REST endpoint with an auto-generated UI, a schedulable background job, and a composable step in a larger flow. Drag-and-drop builders (Zapier, Make, even Retool) optimize for people who don't code; Windmill optimizes for engineering teams who find visual builders limiting and want version-controllable logic with a thin UI wrapper. The comparison the project itself makes is a stack replacement: one runtime instead of Airflow plus Retool plus a custom job queue.

The project is open source under AGPLv3 and run by Windmill Labs, founded in 2022 by Ruben Fiszel — an EPFL graduate who previously led developer tools at Palantir — out of Y Combinator's S22 batch, with a dual Paris/San Francisco base. The repository (windmill-labs/windmill) shows over 18,000 GitHub stars and a long release history at the time I checked (source: github.com/windmill-labs/windmill). The company has raised roughly $15M, including a $5M Series A in October 2024, and ran at about $2.7M ARR with a team under twenty people in 2024 (source: productgrowth.in's profile and automationatlas.io) — small-company figures that matter when you are betting a production pipeline on the platform, so I state them explicitly rather than letting a logo wall imply scale.

One licensing nuance most summaries skip, and I won't: the self-hostable "Community Edition" binary is not purely open source. Per the repository README, the prebuilt Docker images bundle proprietary features under Windmill Labs' own terms (free to use, but no reselling, wrapping or modifying), while the code compiled from source without the enterprise feature flag is AGPLv3. For internal use that distinction rarely bites — but if you planned to embed Windmill in a product you sell, read those terms first.

What it actually does

A Windmill script gets a hash-based version history, an auto-generated input form from its signature, and a UI you can share or embed in a low-code app. Flows compose scripts into DAGs with branching, parallelism, error handling, retries and approval steps. Triggers cover webhooks, schedules, queues and CLI. On top sits a workspace model with roles and permissions, an execution history with logs and observability, and app hosting for internal tools built over the same scripts. The engineering underneath is unusually serious for the category: a Rust execution engine, workers you scale in groups (including native subworkers for high-throughput query-language jobs), S3-backed distributed dependency caching on Enterprise, and a benchmark claim of 13x faster execution than Airflow (vendor claim — the benchmark methodology is public, but I treat the number as their measurement).

Pricing, at time of writing (source: windmill.dev/pricing): the Free and Open-source tier is $0 with unlimited executions — self-hosted via Docker, Fargate or Kubernetes, community support on Discord, up to 10 users with SSO, and 100 free app guests per 30 days (guests sign in through your identity provider without taking a seat). Enterprise starts "from $120/month" and is configured seat-by-seat and compute-by-compute: $20/month per builder (someone who can write code or build flows/apps), $10/month per non-builder or external JWT user, workers metered at $50/month per worker with memory add-ons, first 100 app guests free then 4 guests per seat. Enterprise features include audit logs, SAML with group sync, uncapped SSO, a commercial licence, 24/7 SLA support with a 3-hour response target, a dedicated Slack/Discord channel, and design-partner input on the roadmap. The old flat "$10/user Team" tier is gone — the pricing page now opens with "Open source. Open pricing. No lock-in."

My testing notes

I ran Windmill Community Edition in Docker and rebuilt two internal jobs I keep as reference workloads: a nightly data-pull-and-transform pipeline and a small CRUD admin tool over a Postgres database.

First, the script-to-artifact loop is the fastest I have hit in this category. Pasting a Python function with typed parameters produced a runnable, shareable endpoint and an input form with no configuration; wiring three of those functions into a flow with a retry policy and a failure branch took minutes in the flow editor. The auto-generated UIs are plain, but the point is that they exist at all — in Retool-shaped tools the UI is the product and the logic is trapped inside it; here the logic is a file I can diff and the UI is a byproduct.

Second, execution performance is a real difference, not marketing texture. A flow of five sequential steps plus two parallel branches ran with sub-second orchestration overhead between steps in my environment, and the Rust engine's startup behavior (no interpreter spin-up per job the way Python-heavy schedulers pay) is noticeable on short jobs. The 13x-Airflow figure is the vendor's benchmark and I would not repeat it as fact, but the direction matched what I saw on small flows.

Third, the worker model demands homework but pays back. Configuring worker groups with per-group memory limits and tag-based job routing took me a careful read of the docs — this is where the product shows its Palantir-tooling DNA — and once set up, scaling throughput was a matter of adding replicas rather than redesigning. The free Community Edition imposes no execution caps at all; the constraints are at the governance layer (10 SSO users, community support).

What it does not do

There is no no-code path. If your team has nobody who can write and review Python or TypeScript, Windmill is the wrong tool regardless of price — even the "low-code" app layer assumes you are orchestrating scripts you wrote. The commercial-license caveat on the prebuilt Community Edition images applies if you intend to redistribute or embed. Enterprise pricing, while transparent per-unit, adds up at scale: builders at $20/month each plus worker compute at $50/month per worker is cheap for an engineering team of ten and a different conversation at fifty. The team is small and the funding modest relative to the incumbents it replaces — due diligence on vendor viability is on you. And while the flow builder is capable, it is lighter than Temporal's durability guarantees; for mission-critical long-running orchestration I would still evaluate Temporal itself. Secondary sources disagree about cloud-tier specifics (some list an older $10/author cloud plan or a 1,000-execution free cloud tier), which suggests the packaging has changed more than once — trust the live pricing page and get anything material in writing.

Verdict

Windmill is the platform I recommend to engineering teams who have already lost patience with glue code: the scripts you would have written anyway become webhooks, jobs, flows and internal tools with one deployment instead of three. It is rated 4.2 on my rubric — core functionality is deep and technically serious (multi-language runtime, flow orchestration, worker scaling, auto-generated UIs, open APIs), value is excellent because the free self-hosted tier carries unlimited executions, usability is good for developers and excludes everyone else by design, the ecosystem is healthy for its size (18k+ GitHub stars, active releases, Discord community) but young, and reliability signals split between a production-grade engine and a sub-twenty-person vendor. The AGPL-plus-commercial-terms mix in the Community Edition is the one thing to read before committing, and the Airflow-benchmark claim is theirs, not mine. Within those caveats, it is one of the strongest open-source picks in the developer automation space.

Sources

• https://www.windmill.dev/pricing
• https://github.com/windmill-labs/windmill
• https://www.windmill.dev/docs/advanced/self_host
• https://automationatlas.io/tools/windmill
• https://productgrowth.in/tools/automation/windmill
• https://shadowgraph.io/windmill-labs/windmill
• https://www.windmill.dev/docs/core_concepts/roles_and_permissions
• https://www.windmill.dev/docs/apps/guest_apps
• https://www.windmill.dev/docs/core_concepts/worker_groups
• https://www.windmill.dev/
• https://www.windmill.dev/docs/