Windmill vs n8n vs Make: Workflow Automation Comparison for 2025

For teams evaluating a Windmill vs n8n vs Make workflow automation comparison, the right choice depends on how much code you write, where you host, and how many tasks you run monthly. Each platform occupies a different position on the spectrum from visual no-code builder to developer-first scripting engine, and the differences matter enormously once you move past prototype volumes.

Related: n8n vs Make for E-Commerce Automation in APAC (2025)

At Branch8, we've deployed all three across client engagements in Hong Kong, Singapore, and Australia. This comparison reflects what we've learned building production workflows — not marketing-page promises.

What Problem Does Each Platform Actually Solve?

Before comparing features, it helps to understand the design philosophy behind each tool. They're not interchangeable, and framing them as direct competitors obscures the real decision.

Make (formerly Integromat)

Make is a visual automation platform designed for operations teams and non-developers. Its drag-and-drop scenario builder uses a distinctive circular module layout that maps data flow visually. Make excels at connecting SaaS applications — it offers over 1,800 pre-built app integrations according to Make's official integrations directory. The platform is cloud-only, hosted on AWS infrastructure in the US and EU.

n8n

n8n is a source-available workflow automation tool (licensed under the Sustainable Use License since version 1.0) that bridges low-code and pro-code. It provides a visual canvas similar to Make but adds JavaScript and Python code nodes for custom logic. n8n can run as a cloud service (n8n Cloud) or self-hosted via Docker, making it popular with teams that need data sovereignty. The n8n community has contributed over 400 integration nodes as of early 2025, per the n8n integrations page.

Windmill

Windmill is a developer-first open-source platform (AGPLv3 license) for building internal tools, scripts, flows, and apps. Unlike Make and n8n, Windmill treats scripts as the primary building block — you write Python, TypeScript, Go, Bash, or SQL, and Windmill handles execution, scheduling, error handling, and UI generation. It's designed for engineering teams that want infrastructure-level control without building custom orchestration from scratch.

How Does Self-Hosting Complexity Compare?

Self-hosting is a critical consideration for Asia-Pacific operations. Data residency laws in Vietnam (Cybersecurity Law, Decree 13/2023), Indonesia (Government Regulation 71/2019), and Australia's Privacy Act amendments all push enterprises toward on-premises or regional cloud deployments.

Make: No Self-Hosting Option

Make is cloud-only. There is no self-hosted version available, even for enterprise customers. Data processes through Make's US or EU data centres. For APAC companies handling PII governed by local regulations, this creates compliance friction. Make does offer a dedicated EU instance, but nothing in Asia-Pacific.

n8n: Straightforward Docker Deployment

n8n's self-hosted deployment is well-documented and relatively simple. A single Docker container with a PostgreSQL database handles most use cases. We've deployed n8n on AWS ap-southeast-1 (Singapore) and ap-east-1 (Hong Kong) for clients who needed data to stay within specific jurisdictions. The deployment typically takes a senior engineer two to four hours for a production-ready setup with SSL, backups, and monitoring.

The trade-off: n8n's self-hosted version lacks some features available in n8n Cloud, including native log streaming and certain credential management features. You also take on responsibility for updates, security patches, and scaling.

Windmill: More Infrastructure, More Control

Windmill deploys via Docker Compose or Helm charts on Kubernetes. The architecture is more complex than n8n — it includes separate workers, a scheduler, an LSP (Language Server Protocol) server for in-browser code editing, and a PostgreSQL database. According to Windmill's architecture documentation, a minimal production deployment requires at least three containers.

For a Branch8 client in Taiwan running financial data pipelines, we deployed Windmill on a self-managed Kubernetes cluster on GCP asia-east1. The initial setup took roughly eight engineering hours, including worker auto-scaling configuration. The added complexity was justified because the client's workflows were primarily Python scripts processing regulated financial data that could not leave Taiwan's jurisdiction.

How Capable Are the Code/Script Nodes?

This is where the three platforms diverge most sharply, and it's the dimension that most generic comparisons underweight.

Make: Limited Code Execution

Make does not offer general-purpose code execution. You can write simple expressions using Make's proprietary function syntax within module fields, and there's a basic JSON/text parser. For anything beyond that, you need to call an external API — typically an AWS Lambda function or a webhook to your own server. This works, but it adds latency, infrastructure, and failure points.

Make added a "Custom JS" module in late 2023, but it runs in a sandboxed environment with limited library access. You cannot import arbitrary npm packages or use Python at all.

n8n: Functional Code Nodes with Constraints

n8n provides dedicated Code nodes for JavaScript (Node.js runtime) and, since version 1.19, Python. The JavaScript node supports common built-in Node.js modules and allows importing a curated set of external packages. The Python node runs in a subprocess and supports pip-installed packages when self-hosting.

In practice, n8n's code nodes work well for data transformation, API response parsing, and moderate computation. We routinely use them for tasks like restructuring webhook payloads from Shopify before sending data to NetSuite across our e-commerce clients in Southeast Asia.

The limitation: n8n's code nodes are designed as steps within a visual workflow. They're not intended for long-running scripts (default timeout is 60 seconds on n8n Cloud), heavy computation, or scripts that need persistent state between executions.

Windmill: Scripts Are the Product

Windmill's approach is fundamentally different. Every workflow step is a script with full language support — Python 3.11+ with any pip package, TypeScript/Deno with any npm package, Go, Bash, SQL, and even Rust. The in-browser editor includes IntelliSense (via the LSP server), auto-generated input forms from function signatures, and dependency management.

According to Windmill's benchmarks published on their GitHub repository, a Windmill worker can cold-start a Python script in under 100ms using their dependency caching system. This makes Windmill practical for compute-heavy tasks that would be impractical in Make or n8n.

The trade-off: Windmill requires your team to actually write code. There's no drag-and-drop equivalent for building a workflow step — you open an editor and write a function. For operations teams without engineering support, this is a hard stop.

How Does Error Handling Work in Production?

Error handling separates production-grade automation from demo-day automation. When a workflow runs 50,000 times per month across payment processing, inventory sync, and customer data pipelines, silent failures cost real money.

Make: Visual Error Routes

Make uses a visual error-handling model where you can attach error handler routes to any module. This is intuitive — you can see the error path directly in the scenario builder. Make also provides built-in directives: Rollback, Commit, Ignore, and Break. The Break directive is particularly useful — it stops the scenario and moves the execution to the incomplete executions queue for manual review or automatic retry.

For teams managing automation without dedicated engineers, Make's error handling is the most accessible of the three.

n8n: Error Workflows and Try/Catch

n8n offers error triggers that can fire a separate workflow when any workflow fails. Within a workflow, you can use the "On Error" settings on individual nodes to continue on failure, retry, or stop. Since version 1.20, n8n added try/catch-style error handling as a native workflow pattern.

In our experience, n8n's error handling is adequate for most integration workflows but requires discipline. The error trigger sends useful metadata (workflow name, execution ID, error message), but you need to build your own alerting pipeline — typically routing errors to Slack, PagerDuty, or a custom dashboard.

Windmill: Programmatic Error Handling with Retries

Windmill provides configurable retry policies per step (with exponential backoff), error handlers at the flow level, and — because each step is code — native try/except or try/catch within the script itself. Windmill also maintains detailed execution logs with input/output for every step, stored in PostgreSQL and queryable via API.

For the Taiwan financial data pipeline mentioned earlier, we configured Windmill's retry policy to attempt three retries with 30-second exponential backoff before routing failures to an error-handling flow that logged the failure to a compliance audit database. This level of granularity would require significant custom work in Make or n8n.

What Does Enterprise-Scale Pricing Actually Look Like?

Pricing comparisons at small volumes are misleading. The real question is what happens at 100,000+ tasks per month, which is routine for companies running cross-border operations across APAC.

Make: Operations-Based Pricing

Make charges by operations (each module execution counts as one operation). As of Q1 2025, the Teams plan costs $16.67/month (billed annually) for 10,000 operations. At 100,000 operations/month, you're looking at the Teams plan at approximately $84/month with add-on operation packs according to Make's pricing page. At 500,000 operations/month, costs approach $300-400/month.

The catch: Make counts every module in a scenario as an operation. A 10-module scenario processing 1,000 records uses 10,000 operations. This multiplication effect surprises many teams when they move from testing to production.

n8n: Execution-Based Pricing (Cloud) or Free (Self-Hosted)

n8n Cloud's Starter plan begins at $20/month for 2,500 executions. The Pro plan runs approximately $50/month for 10,000 executions. At high volumes, n8n Cloud becomes expensive — 100,000 executions would require the Enterprise tier with custom pricing.

Self-hosted n8n has no execution limits. You pay only for infrastructure. On AWS ap-southeast-1, a t3.medium instance (adequate for moderate n8n workloads) runs approximately $30/month. This makes self-hosted n8n dramatically cheaper at scale, though you absorb operational overhead.

Windmill: Computation-Based Pricing or Free Self-Hosted

Windmill Cloud's free tier includes 1,000 executions per month. The Team plan starts at $10/month per user with additional execution costs. Self-hosted Windmill Community Edition is free under AGPLv3 with unlimited executions. The Enterprise Edition (required for SSO, audit logs, and priority support) uses custom pricing.

Self-hosted Windmill's infrastructure cost is higher than n8n due to the more complex architecture. Expect $60-120/month on cloud infrastructure for a production deployment handling 100,000+ monthly executions, based on our deployment experience.

Which Platform Fits Which Team?

The Windmill vs n8n vs Make workflow automation comparison ultimately maps to team composition and use case.

Choose Make When

• Your team is operations-focused without dedicated engineers
• You need rapid integration between established SaaS tools (Salesforce, HubSpot, Shopify, Slack)
• Data residency in Asia-Pacific is not a hard compliance requirement
• Monthly task volumes stay under 200,000 operations
• Speed-to-deploy matters more than customisation depth

Choose n8n When

• Your team includes developers but also non-technical operators who need to build workflows
• You need self-hosting for data sovereignty (Vietnam, Indonesia, Australia, or China-adjacent operations)
• Workflows mix SaaS integrations with moderate custom code
• You want a visual interface but need escape hatches into JavaScript or Python
• Budget is constrained and you can manage self-hosted infrastructure

Choose Windmill When

• Your team is primarily engineers writing Python, TypeScript, or Go
• Workflows involve heavy computation, data transformation, or internal tooling
• You need granular error handling with audit trails for compliance
• You're replacing cron jobs, Airflow DAGs, or custom orchestration code
• You want the flexibility of code with the operational benefits of a managed platform

What Are the Real-World Trade-offs Nobody Mentions?

Every platform comparison has gaps that only surface during implementation. Here are the ones we've encountered across multiple APAC deployments.

Make's Operation Counting Is Expensive at Scale

We've seen clients project costs based on "scenarios per month" and then face 5-10x higher bills because each scenario step multiplies the operation count. A client in Singapore running a 15-step order processing scenario across their Shopify Plus stores hit their 40,000-operation monthly cap within the first week.

Related: our guide on shopify plus store

n8n's Community Nodes Are Hit-or-Miss

n8n's community node library is growing, but quality varies. We've encountered community nodes for APAC-specific services (LINE Messaging API, WeChat Work) that hadn't been updated for breaking API changes. Budget time for building custom HTTP Request node configurations as a fallback.

Windmill's Learning Curve Is Real

Windmill's documentation is thorough but assumes developer fluency. For teams used to visual builders, the transition takes two to three weeks of active use. The in-browser IDE is impressive — IntelliSense, type checking, real-time preview — but it's still a code editor, not a canvas.

Branch8's Recommendation

We maintain active deployments of all three platforms across our client base. Our default recommendation for most APAC operations teams is n8n self-hosted — it hits the right balance of visual accessibility, code capability, self-hosting simplicity, and cost at scale. For engineering-heavy teams replacing internal tooling or Airflow pipelines, we recommend Windmill. For fast-moving marketing and sales operations teams that don't need data residency controls, Make remains the fastest path to production.

The Windmill vs n8n vs Make workflow automation comparison doesn't have a universal winner. The right answer depends on who's building, what they're building, and where the data needs to live.

Need help choosing or deploying workflow automation across your Asia-Pacific operations? Branch8 designs, builds, and manages automation infrastructure for companies operating in Hong Kong, Singapore, Taiwan, Australia, and Southeast Asia. Get in touch with our team to discuss your requirements.

Sources

• Make Official Integrations Directory: https://www.make.com/en/integrations
• n8n Integrations Library: https://n8n.io/integrations
• Windmill Architecture Documentation: https://www.windmill.dev/docs/misc/architecture
• Windmill GitHub Repository and Benchmarks: https://github.com/windmill-labs/windmill
• Make Pricing Page: https://www.make.com/en/pricing
• n8n Pricing Page: https://n8n.io/pricing
• Vietnam Decree 13/2023 on Personal Data Protection: https://thuvienphapluat.vn/van-ban/Cong-nghe-thong-tin/Nghi-dinh-13-2023-ND-CP-bao-ve-du-lieu-ca-nhan-357384.aspx
• n8n License (Sustainable Use License): https://github.com/n8n-io/n8n/blob/master/LICENSE.md