Contents
- Verdict
- What is Windmill?
- Best for, and not for
- Strengths and limits
- Pricing
- What people actually build with Windmill
- What Windmill actually costs at small-business volume
- The gotcha: AGPL, and buying capacity you cannot burst
- What breaks in production, and how you find out
- What it connects to that you already run
- Windmill alternatives: what to pick instead, and when
- Migration and lock-in: can you get your work out?
- FAQ
Windmill is excellent for engineering teams and the wrong tool for everyone else, and its published pricing makes that explicit. As of August 2026 the free open-source edition allows unlimited executions with up to 50 users, three workspaces and 10GiB of storage, which is an unusually generous free tier. Enterprise starts at $120 a month, but the real structure is per-resource: $20 a month per developer seat, $10 per operator, and $50 a month per standard worker. That worker pricing is the number to model, because it means capacity is bought in units of parallel compute rather than volume of work - a very different budgeting exercise from every per-task tool in this category.
What is Windmill?
Windmill is an open-source, code-first platform that turns scripts in Python, TypeScript, Go, Bash, SQL, and other languages into scheduled jobs, webhook APIs, multi-step workflows, and auto-generated internal UIs. Its Rust-based job engine benchmarks as one of the fastest workflow engines around, and it positions itself as an alternative to both Airflow and Retool. It is really a developer platform with automation attached rather than a no-code tool.
Best for
Engineering teams that want to turn their scripts into reliable scheduled jobs, workflows, and internal tools.
Not for
Non-technical teams expecting drag-and-drop app connectors. Windmill orchestrates code you write; if you do not write code, there is nothing here for you and the excellent free tier is irrelevant.
Strengths
- Very fast Rust-based execution engine, which matters when you are paying for parallel workers rather than runs
- Write steps in Python, TypeScript, Go, Bash, SQL and more, rather than a proprietary expression language
- Auto-generates UIs and APIs from scripts, plus a low-code app builder, which turns internal tooling into a side effect
- Free self-hosted edition allows unlimited executions with up to 50 users - unusually generous for a tool of this capability
- Handles serious scale and long-running jobs far better than app-connector tools, which time out
- SOC 2 compliance and real enterprise adoption, so it clears procurement where hobby tools do not
- Because steps are ordinary code in mainstream languages, the logic is portable to any other runtime by definition
Limitations
- Firmly a developer tool - non-programmers will not get anywhere, and no amount of UI polish changes that
- Not built around a SaaS connector catalogue, so integrating with your CRM means writing API calls yourself
- Worker-based pricing is a different mental model and can surprise you: reserving parallelism costs money even when idle
- Ongoing community friction about which capabilities sit behind the enterprise licence, particularly around workers at scale
- AI capabilities centre on assisting with code and flows rather than a turnkey agent product
- Smaller template library and ecosystem than mainstream automation platforms, so you start from a blank file more often
Windmill pricing
Windmill's free open-source edition is unlimited on executions with caps on users, workspaces and storage. Enterprise pricing as of August 2026 is composed rather than tiered: a starting price of $120 a month, plus $20 per developer seat per month, $10 per operator or external JWT user, $50 per standard worker per month at a 2GB memory limit, and $50 a month for up to eight native subworkers. Agent workers cost nothing when idle. The consequence is that your bill tracks how much parallel compute capacity you reserve and how many people build, not how many times a workflow runs - which is cheap for high-volume, short-duration jobs and expensive if you need lots of parallelism for occasional bursts.
| Plan | Price | What you get |
|---|---|---|
| Free / open source | $0 | Unlimited executions, up to 50 users, 3 workspaces, 10 SSO users, 10GiB storage (as of Aug 2026) |
| Enterprise (from) | $120/mo | Unlimited executions, users and workspaces, unlimited storage, 24/7 priority support with 3h response |
| Builder seat | $20/mo | Per builder (Windmill's name for a developer seat); non-builders are $10/mo (rechecked 17 Nov 2026) |
| Standard worker | $50/mo | Per worker, 2GB memory limit; $50/mo covers up to 8 native subworkers; agent workers free when idle |
| Self-hosted Enterprise | Custom | Same features plus audit logs, S3-backed dependency cache, SAML with group sync |
Pricing reflects public plans as of August 6, 2026 and can change. Check Windmill for the latest.
What people actually build with Windmill
Windmill orchestrates code, so the builds that land here are the ones a team was already writing scripts for and running badly: cron entries on somebody's laptop, a scheduled function nobody can find, a Python file that lives in one person's home directory.
The builds that land
Nightly data synchronisation between a database and a business system. A scheduled TypeScript or Python script reads yesterday's rows, transforms them, posts them to an API, and writes a summary to Slack. Windmill gives it a schedule, a run history, secrets management and a retry policy, which is the entire difference between a script and a system.
An internal tool with a form in front of it. Windmill auto-generates a UI from a script's arguments, so a developer writes a function that issues a refund or re-runs an import, and an operator gets a button. This is what the $10 operator seat exists for, and for many teams it replaces a separate internal-tools product outright.
Bulk document or data processing that would time out anywhere else. Long-running jobs are Windmill's home ground: a connector-based automation platform will cut you off after a few minutes, and Windmill will not.
An inbox triage job at our reference volume of 1,000 items a month. A script pulls messages, calls a model once per item to classify and extract, applies rules and files the result. On Windmill that is free at any volume, because the meter does not exist; you pay for workers and people.
A webhook receiver that does real work. Scripts become HTTP endpoints, so anything that fires a webhook can trigger a job with proper idempotency and error handling around it.
What Windmill is genuinely bad at
Anything a non-programmer needs to build or change. There is no connector catalogue, so integrating with your CRM means reading its API documentation and writing the call, and no amount of interface polish substitutes for someone who can write the function. This is the reason most Windmill evaluations end, and it ends them regardless of how generous the free tier is.
It is also poor value for spiky low-volume work, because a worker you need for one hour a week still costs $50 a month.
Bottom line: Windmill turns scripts a team already has into scheduled, monitored, form-fronted services, and gives a non-programming team nothing at all.
What Windmill actually costs at small-business volume
Windmill is the outlier in this directory: it does not meter your work at all. There is no per-task, per-execution, per-operation or per-credit charge. The free open-source edition runs unlimited executions, and the paid edition prices seats and compute capacity instead. Our reference workload of 1,000 triage runs a month is therefore free on Windmill, and so is 200,000 runs a month, and so is two million. What you pay for is people and parallelism.
Concretely, as of August 2026 the free edition allows unlimited executions with up to 50 users, 3 workspaces, 10 SSO users, 10GiB of storage and a cap of 100 emails a day on email triggers. Enterprise starts at $120 a month. The components are $20 a month per developer, $10 a month per operator or external JWT user (counted as half a seat), and $50 a month per standard worker at a 2GB memory limit, with a further $50 covering up to eight native subworkers. The pricing page's own starting configuration is two standard workers at $100 a month plus the eight subworkers at $50.
That means the budgeting exercise is completely different from everywhere else on this site. You do not forecast volume; you decide how many jobs must run in parallel and how many people build. A small business with one developer and one worker is looking at a low three-figure monthly bill regardless of whether the automations run a hundred times a day or a hundred thousand. Meanwhile the free edition's 50-user allowance means most small businesses never need the paid tier for licensing reasons at all - they buy it for support and the enterprise features, not for capacity.
The inversion point is worth stating plainly. Windmill is dramatically cheaper than per-task tools for high-volume, short-duration work, and dramatically more expensive for low-volume work that needs a lot of parallelism in occasional bursts - because a worker you need for one hour a week still costs $50 a month. Model peak concurrency, not average volume.
| Line item | Free edition, self-hosted | Enterprise (starting configuration) |
|---|---|---|
| Software licence | $0, AGPLv3 core with proprietary enterprise parts excluded | $120/mo base plus a commercial licence |
| Executions | Unlimited | Unlimited |
| Seats | Up to 50 users, 10 SSO | $20/developer, $10/operator, unlimited |
| Compute | Your own workers, your own machines | $50/standard worker; starting config is 2 workers at $100 plus 8 subworkers at $50 |
| Server | $20-$50/mo for Postgres and worker containers | Included on cloud |
| Maintenance | 2-4 hrs/mo of someone technical | Vendor, with a 3-hour response commitment |
| Realistic all-in monthly | $20-$50 plus 2-4 hrs of staff time | $270 and up on the published starting configuration |
Self-host versus Enterprise, honestly costed
Nearly everyone reading this should run the free edition, so the real comparison is free self-hosted against Enterprise, not against a cloud meter. Self-hosted, the software is $0 and you provide a server with Postgres behind it and one or more worker containers. Call that $20 to $50 a month for a small business, more if jobs are memory-hungry, because the standard worker specification of 2GB is a real constraint.
The maintenance number is the honest one people skip. The GitHub API on 6 August 2026 showed 17,457 stars, 806 open issues and a push that same day, so the project is unambiguously alive and moving. Alive and moving means upgrades, and Windmill upgrades touch a database schema and a fleet of workers rather than a single container. Two to four hours a month covers upgrades, worker sizing, dependency pinning and watching queue depth. That last one is not optional: on a reserved-capacity model, the symptom of being under-provisioned is lateness rather than an error.
What Enterprise buys is not capacity you cannot get for free. It is the 24/7 support commitment with a three-hour response, audit logs, SAML with group sync, a distributed dependency cache and a commercial licence that removes the AGPL obligation. Buy it for the support and the licence, and do the sums on the staff hours you would otherwise spend at 2am.
Bottom line: Windmill does not meter runs at all, so 1,000 triage jobs a month cost the same as two million: budget peak parallelism and headcount, not volume.
The gotcha: AGPL, and buying capacity you cannot burst
The licence is the decision most people get to late and should get to first. Windmill's open-source edition is licensed under the GNU Affero General Public License version 3. AGPL is genuine open source and it is copyleft with a network clause: if you modify Windmill and make it available to users over a network, you are obliged to offer those users the corresponding source. For internal business automation this is a non-issue - you are the user, and you can modify freely. For anyone planning to build a customer-facing product on top of a modified Windmill, it is a significant obligation and it is the opposite end of the spectrum from an MIT-licensed alternative. Read it before you architect around it, and take advice if you are shipping a product.
The commercial gotcha is that workers are a reservation, not an elastic pool. Because capacity is bought in $50-a-month units of parallel compute, you are sizing for your peak and paying for it during your trough. That is entirely fair - it is how infrastructure works - but it is unfamiliar to anyone whose mental model comes from per-task automation tools where a quiet month is a cheap month. On Windmill a quiet month costs exactly the same as a busy one, which is a feature if your volume is growing and a cost if your volume is seasonal.
The third thing to watch is the seat taxonomy. Developers are $20 and operators are $10 as of August 2026, and the difference is what someone is allowed to do rather than how much they use it. Classify your people honestly at the start - most staff who merely trigger and observe jobs are operators, not developers, and getting that wrong in either direction is either an overspend or an access problem.
Bottom line: Workers are reserved capacity, so a quiet month costs exactly what a busy one does, and the AGPL network clause only bites if you modify Windmill and expose it to outside users.
What breaks in production, and how you find out
The thing that stops most Windmill evaluations is not a bug, it is the audience mismatch. Windmill orchestrates code you write. There is no meaningful drag-and-drop connector catalogue of the kind a non-technical operator expects, and no amount of a generous free tier compensates for that. Projects fail here when someone chooses it on price and then discovers nobody on the team can author a script.
For teams who can, the operational profile is closer to running infrastructure than to using SaaS. Self-hosting means you own the Postgres database behind it, the worker containers, the upgrades and the backups. The Rust-based execution engine is fast and resource-efficient, which is exactly what you want when you are paying per worker rather than per run, but the workers are still processes on machines that need watching. Worker memory is the practical constraint - a standard worker is specified at a 2GB memory limit, and a job that exceeds it is your problem to diagnose.
The failure mode specific to a reserved-capacity model is queueing. When every worker is busy, new jobs wait. Nothing errors and nothing is lost, but a time-sensitive job arrives late, and the fix is to buy another worker rather than to optimise the script. Monitor queue depth from the start, because it is the metric that tells you your capacity is wrong, and it is not the metric anyone thinks to watch when they arrive from a per-task platform.
On project health, the repository answers the question directly rather than by reputation: on 6 August 2026 the GitHub API showed the last push earlier that same day, alongside 806 open issues on 17,457 stars. An open-issue count that size on a project of that size is normal for an actively used developer tool and is not a warning sign; a stale pushed_at date would have been.
We could not retrieve a readable version of Windmill's plan-comparison documentation page when we checked in August 2026 - it returned no content - so confirm the precise enterprise feature boundaries in the live documentation rather than relying on any summary, including this one.
Bottom line: On a reserved-capacity platform the characteristic failure is lateness, not errors, so alert on queue depth or you will find out from whoever was waiting for the report.
What it connects to that you already run
Set expectations correctly: Windmill's integration model is libraries, not connectors. You write steps in Python, TypeScript, Go, Bash or SQL, which means the things you integrate with are whatever those languages have client libraries for - which is everything. Your accounting package, your CRM, your database, an internal service with no public API: all reachable, all requiring someone to write the code.
That is a worse experience than a connector catalogue for the first simple integration and a better one for the tenth complicated one. There is no waiting for a vendor to support an app, no discovering that the official connector omits the one action you need, and no expression language standing between you and the API. For a team that already writes code, this removes an entire category of frustration.
Windmill also does something most automation platforms do not: it turns scripts into internal apps and forms with generated UIs, so a script a developer wrote can be handed to a non-technical colleague as a button they press. For a small business, that pattern - developers write, operators run - is often the most valuable thing here, and it is what the $10 operator seat exists for.
Bottom line: Anything with a client library or a REST API is reachable, and every one of those integrations is code you write once and then maintain forever.
Windmill alternatives: what to pick instead, and when
The honest triage question is whether your team writes code. If the answer is no, stop reading the Windmill pricing page: nothing on it will help you, and the alternatives below all will. Pick n8n if you want a visual builder with hundreds of maintained connectors and the option to drop into a code node when you need to, which is the closest thing to a middle ground. Pick Activepieces if you want the same shape with an MIT licence and free self-hosting with no cap on runs, users or flows. Pick Make.com if the work is high-volume deterministic branching and you want the cheapest per-step meter available.
If your team does write code, the comparison narrows to how you want to pay for compute. Pipedream bills credits defined as compute time, which suits bursty low-volume work far better than reserved workers do. Latenode bills per CPU second with no base fee, which for the reference workload of 1,000 short runs a month lands inside its free allowance. Windmill's reserved workers only beat both once your volume is high and steady enough that unlimited executions is worth paying a fixed capacity bill for. And if the answer is that nobody wants to own any of this, Autonoly is a managed service rather than a platform.
| Tool | Billing unit | Monthly cost at the reference workload | Who it suits | Does better than Windmill |
|---|---|---|---|---|
| Windmill | Seats and reserved workers; runs are unlimited | $0 on the free edition, plus $20-$50 of server | Teams that already write Python or TypeScript | Unlimited executions and long-running jobs |
| n8n | Execution (whole workflow run) | EUR 20/mo Starter covers 2,500 executions | Mixed teams who want connectors and code nodes | Hundreds of maintained business connectors |
| Activepieces | Credit: 1 per flow run, steps free | $20/mo Plus, or free self-hosted with no run cap | Non-developers who still want to self-host | MIT licence and a builder a non-coder can use |
| Make.com | Operation (one step) | $9/mo Core covers 10,000 credits; 5,000 used here | Deterministic, branchy, high-step-count workflows | Lowest cost per step in this comparison |
| Pipedream | Credit, defined as 30 seconds of compute at 256MB | Free tier covers this volume; paid tier prices unverified | Developers with bursty, low-volume workloads | Paying for compute used rather than compute reserved |
| Latenode | CPU second | Inside the 10,000 free CPU seconds for short runs | Teams wanting usage billing with no base fee | No fixed monthly floor at all |
Bottom line: If nobody on the team writes code, every alternative here beats Windmill; if they do, the choice is reserved workers against per-compute billing, and 1,000 runs a month is too little to justify reserving.
Migration and lock-in: can you get your work out?
Windmill has arguably the weakest lock-in of anything in this directory, and it is by design - the pricing page leads with the claim of open pricing and no lock-in, and for once the structure supports the slogan. Your automations are scripts in mainstream languages, stored as files, versionable in git. A Python script that reads from your database and posts to an API is not a Windmill artefact in any meaningful sense; it is a Python script that Windmill happens to schedule. Move to a different orchestrator and the substance of the work moves with it.
The licence is worth stating exactly, because it is neither as simple as AGPL nor as restrictive as the source-available terms elsewhere in this category. The repository's LICENSE file says code is variously licensed: the backend and frontend are AGPLv3 except for snippets compiled under an enterprise flag or gated behind a licence check, which are proprietary and commercial, and forks are explicitly forbidden from including that proprietary code. The language clients are separately licensed. The practical reading for a business is that the open core you would actually run is genuine copyleft open source, so nobody can take it away, discontinue your edition or reprice you off it. That is a materially stronger position than a fair-source licence that grants fewer rights than its marketing implies.
What you would rebuild on a move is the orchestration layer around the code: the schedules, the flow definitions that chain scripts together, the generated app UIs, the resource and variable definitions holding your credentials. That is real work but it is the smaller half, and it is configuration rather than logic. The pragmatic advice is simply to keep scripts in git from day one rather than authoring them only in the web editor - which is good practice for its own sake and happens to make your exit free.
Bottom line: Windmill's open core is AGPLv3 with only the enterprise-flagged code proprietary, and because your logic is ordinary Python or TypeScript in git, leaving costs you the schedules rather than the work.
Windmill FAQ
How much does Windmill cost?
The open-source edition is free with unlimited executions, capped at 50 users, three workspaces and 10GiB of storage as of August 2026 - which covers a lot of small businesses outright. Enterprise starts at $120 a month and then composes: $20 per developer seat, $10 per operator, $50 per standard worker at 2GB memory, and $50 for up to eight native subworkers. Model the workers first, because that is usually the largest line and it is bought as capacity rather than usage.
Why does worker-based pricing matter?
Because it inverts the usual calculation. Per-task tools charge you more the more work you do; Windmill charges for how much parallel capacity you reserve, and then the work itself is unlimited. If you run a million short jobs through two workers, that is $100 a month of workers. If you need twenty workers standing by for an occasional burst, that is $1,000 a month whether the burst comes or not. High steady volume is cheap here; spiky low volume is not.
What breaks with Windmill in production?
Worker saturation is the characteristic failure: jobs queue rather than fail, so the symptom is lateness rather than an error, and nobody notices until someone asks why the nightly report is arriving at lunchtime. Second, the 2GB memory limit on standard workers bites on data-heavy jobs, which then need a larger worker and a bigger bill. Third, dependency drift in scripts - a Python package updates and a job that ran fine for a year stops. Pin dependencies and alert on queue depth.
Who is Windmill wrong for?
Anyone who was shopping for a Zapier alternative. Windmill is closer to a modern replacement for a job scheduler and an internal-tools builder than to an app-connector automation platform, and it has nothing like a connector catalogue - integrating with your CRM means reading their API documentation and writing the call. If nobody on your team writes code, the free tier's generosity is beside the point and you will not get a first automation live.
Does Windmill integrate with our business tools?
Through code, which is both the answer and the caveat. Anything with a REST API is reachable, and there are resource types for common databases, object storage and services. What you do not get is a pre-built, tested, maintained connector for QuickBooks or Shopify where someone else has already handled the pagination and the auth refresh. Budget an hour or two per integration the first time, and remember that maintaining it when the vendor changes their API is now your job.
How locked in are we?
Less than almost anything else here, because the valuable part is ordinary code. Your scripts are Python, TypeScript, Go or SQL files that run anywhere - Windmill supplies scheduling, secrets, workers and a UI around them. Migrating means replacing that scaffolding, not rewriting your logic. Combined with a free self-hostable edition, that puts you in a strong position: you can leave, and you can also simply stay on the free edition indefinitely if pricing changes.
Is Windmill actually open source?
The core is open source and free to self-host with unlimited executions, and the free tier is genuinely usable rather than crippled. Some advanced capabilities require an enterprise licence, and there has been ongoing community debate about where that line sits, particularly around running many workers at scale. The practical step is to check the feature matrix against the specific things you need - audit logs, SAML, high worker counts - before assuming the free edition covers your case.
Can Windmill run AI workflows?
Yes, in the sense that a script can call any model API and Windmill has added AI assistance for authoring code and flows. What it does not offer is a no-code agent builder, so AI workflows here remain a programming exercise. For a team that already writes code that is often an advantage - you get full control over prompting, retries, validation and cost - but it is not the product to pick if you wanted an agent you could configure rather than write.
Can you build our scheduled jobs on Windmill?
Yes, and code-first platforms are where a handover matters most, because the automation is only as maintainable as the code and the documentation behind it. We scope on a free automation audit, build against your own instance so you own the deployment and the scripts outright, and hand over with documentation plus a recurring plain-language report of what ran, what it saved and what needs attention. Because the logic is ordinary code on a self-hostable platform, nothing about it depends on us staying involved.
Looking at alternatives? Windmill and Autonoly barely compete for the same buyer. Windmill is for engineers who already have scripts and want an excellent engine to run them, and on lock-in it is in an unusually strong position precisely because your logic is ordinary Python or TypeScript that runs anywhere - the platform provides scheduling and infrastructure, not the intelligence. Autonoly is for people who have tasks and no scripts. If your team writes code and wants orchestration, Windmill is genuinely one of the best options in its class. If nobody on the team codes, plain-English tasks and a scheduler get you to a working automation far sooner. See the Autonoly review.
