Windmill vs Make

Anyone in the business. The Free plan already includes the no-code visual workflow builder, routers and filters and the app catalog, so dragging modules onto a canvas and mapping fields between them needs no engineer, no infrastructure and no deploy. For connecting two SaaS tools this is genuinely the faster path of the two.

Sharing is a plan boundary. Per the pricing page, teams and team roles, plus creating and sharing scenario templates, start on the Teams plan. Role-based access that controls who can build and change what is listed on the enterprise page.

Whoever built it, usually in the canvas itself. A scenario can be exported as a blueprint JSON file for backup or reuse, but that file carries modules, settings and mapped values rather than reviewable logic, and an imported blueprint has to be under 2 MB.

Build a scenario on a canvas: add modules from the app catalog, map fields between them, and branch with routers and filters. Make's own definition is that a scenario "defines how different apps communicate and work together in ways they wouldn't normally be able to". Every module run is metered, with two documented exceptions: the Router module and the error-handler modules (Rollback, Break, Resume, Commit, Ignore) consume no credits.

The in-product code surface is custom functions, and they are deliberately small: JavaScript ES6 only, Enterprise only, no third-party libraries, no HTTP requests, no recursion and no calling another custom function, synchronous only, at most 5,000 characters, and "a single custom function can't run for more than 300 milliseconds". They extend data transformation, they do not host business logic.

Scenario authoring happens in the browser. Access to the Make API, which the pricing page puts at 300+ REST endpoints and which can read a scenario's blueprint as JSON, starts on the Core plan. There is no local runtime to test a scenario against: a run happens on Make, and the Visual Studio Code route for building custom apps is marked deprecated in Make's developer docs.

There is no package layer. Custom functions state plainly that "no 3rd party libraries are supported", so anything the catalog does not already cover is reached through an HTTP module or a custom app you declare in JSON against a public API.

Connections are held by Make and authorized once through the app, which is a real convenience: you never handle the token. Exported blueprints deliberately leave them out, so anyone importing one sets up their own connections afterwards. Custom variables start on the Pro plan.

No Git sync for scenarios. The closest equivalent is the blueprint: export it from the three-dot menu or read it through the API, then import it elsewhere. That gives you a file to keep, but the diff is of Make module references, mappers and designer coordinates rather than of the logic, and re-exporting is a manual step after every change.

Make now points AI at the parts of the product that are text. Its custom apps documentation lists three ways to build an app and recommends an AI coding agent ahead of the Make web interface, with the Visual Studio Code route marked deprecated.

This is where Make wins outright. The pricing page puts the catalog at 3,500+ apps, and Make's app documentation splits them into verified apps that Make builds and supports, custom apps built by users, community apps and built-in apps. Enterprise adds complex applications that Make names as Workday finance modules, Coupa, ServiceNow, Greenhouse and Infor M3. Nothing in a code-first platform matches the time-to-first-working-automation on a long-tail SaaS tool Make already supports.

Scenarios run on a schedule (interval, once, daily, weekdays, weekly, monthly, specific dates or on demand), and an "Immediately" option exists for some triggers only. The minimum interval is a plan boundary: 15 minutes on Free, with "more control with scheduled scenarios, down to the minute" starting on Core. Webhooks are supported, with a maximum payload of 5 MB regardless of tier.

Build a custom app to reach anything with a public API. A module is declared as JSON: a communication block that templates the request and response, and a mappable-parameters block that defines the fields a builder fills in. For one-off calls inside a scenario there is the HTTP module, and for transformations, Enterprise custom functions.

Make also works in both directions. Its hosted MCP server at mcp.make.com/v2 runs over stateless Streamable HTTP: scenario-run tools are available on all plans, management tools require a paid plan, and a run call that exceeds 25 seconds over OAuth or 40 seconds with an API key returns an execution id while the scenario keeps running for up to 40 minutes. In the other direction, a Make AI agent can take module tools, whole scenarios or external MCP servers as its tools.

Minutes, and no infrastructure. Pick the trigger, add modules, map the fields, turn the scenario on. Starting from someone else's work is easy too: blueprints import from a JSON file or the clipboard, and creating and sharing scenario templates is a Teams plan feature. If your automation is two SaaS apps and a filter, Make will get you there first.

Better than nothing, and still not portable. A blueprint export gives you a JSON file, but its contents are Make's own structures: a flow array where each entry names a module type by URI, with its mapper, parameters and designer coordinates in metadata. Nothing in it runs outside Make, and connections are excluded, so a move means rebuilding each module, mapping and filter on the new platform.

Make is often the right place to stay. Low-volume, broad-catalog, non-developer automation is what it is built for, and replacing it with code you have to maintain is a real cost. The migration case is specific: high volume, logic that outgrew what a 300-millisecond custom function can hold, or a requirement that the automation run on your own infrastructure.

Every run is visible in the scenario's execution history. Full-text execution log search starts on the Pro plan. Make's security page puts default log retention at 30 days, with longer storage for Enterprise customers, and the enterprise page adds real-time analytics and Make Grid, "a live view of every automation and agent across the company".

Audit logs that record changes are listed under governance on Make's enterprise page, alongside role-based access and scenario tagging: Enterprise only.

Make's security page lists GDPR, SOC 2 Type II and SOC 3, an ISO 27001 certified information security program, AES-256 full-disk encryption at rest with AWS KMS, and TLS 1.2 and 1.3 in transit. Sign-in is supported with Google, Facebook and GitHub; using your own SSO implementation is Enterprise only.

Scenarios are organized under an organization, with teams and team roles from the Teams plan up. Execution always happens on Make's infrastructure: AWS EC2 private instances across two zones, with the Enterprise platform running in a separately managed AWS environment isolated from self-service customers.

Limits are plan-shaped. A run that goes past 45 minutes ends with an ExecutionInterruptedError and leaves the remaining bundles unprocessed, and that ceiling is 10 minutes on the Free subscription. Data transfer is proportional to credits, at 5 GB per 10,000 credits licensed per month, and running out of it raises a DataSizeLimitExceededError that immediately disables scenario scheduling. Maximum file size also varies by subscription. Priority scenario execution starts on the Pro plan.

Make is a hosted service, and not open source. The pricing page lists cloud plans only, and the security page describes infrastructure on AWS EC2 private instances across two zones reachable only through a private network. The parts open to developers are the Make API, the MCP server and the custom apps format.

In credits, which replaced operations as the billing unit: 1 operation equals 1 credit by default and "most actions consume 1 credit", with some AI features consuming more. Free includes 1,000 credits a month. At the 10,000 credits a month tier with annual billing, the pricing page lists Core at 12 USD a month, Pro at 21 USD and Teams at 38 USD, with Enterprise custom. Extra credits cost 25% more than the credits included in a plan, and unused credits expire at the end of the term.

Cost tracks module actions, which is cheap and predictable at low volume and the main reason teams eventually look elsewhere. Make's own help center illustrates the upper end with a plan at 338.13 USD a month for 500,000 credits, and notes that Core now covers up to 300,000 credits a month while Pro reaches up to 8 million.