Make — the platform formerly called Integromat — occupies a specific and useful position: more capable than the simple trigger-action tools, far less demanding than running your own automation server. Its defining feature is that you can see the whole workflow as a diagram, including the branches, the loops and the bits that handle failure. For a business whose processes have genuine "it depends" logic in them, that visibility is the difference between an automation you trust and one you babysit.
Scenarios, modules and the visual model
Make calls a workflow a scenario. Each step is a module, and modules are laid out on a canvas connected by lines, rather than stacked in a list. This sounds cosmetic and is not. When a scenario has a router splitting into four paths, two of which loop over line items, a diagram is comprehensible and a vertical list is not.
Three module types do most of the heavy lifting and have no clean equivalent in simpler tools:
- Router — splits the flow into multiple paths, each with its own filter. This is how "commercial jobs go to Dave, residential go to the scheduling queue, anything over £5,000 needs approval" gets expressed without three separate workflows.
- Iterator — takes an array and processes each element in turn. Order line items, multiple attachments, a list of recipients: anything shaped "for each of these" is a one-module job.
- Aggregator — the inverse. Collapses many items back into one, which is how you turn twelve separate events into one digest email rather than twelve emails.
What Make costs, and how credits actually work
| Tier | Listed price | What you get |
|---|---|---|
| Free | $0/mo | Up to 1,000 credits/month |
| Core | from $9/mo | Entry credit bundle; scales with a slider |
| Pro | from $16/mo | Adds priority execution and custom variables |
| Teams | from $29/mo | Multiple users and shared scenario folders |
| Enterprise | Custom | Not published — contact sales |
Prices shown are for monthly billing; Make states annual billing saves 15% or more. Credit allowances scale within each tier, so the entry price is a floor, not a ceiling. Source: the vendor’s own pricing page, read August 5, 2026. Prices change — verify before you commit.
The billing difference that matters
Make bills per module execution — roughly, per step that runs. That sounds identical to Zapier's task model, and at low volume it broadly is. The difference shows up in two places.
First, filtered-out branches cost nothing. In a router with four paths, only the path that matches consumes operations. A scenario with a lot of conditional logic therefore costs far less than its module count suggests.
Second, and more importantly, the entry price is dramatically lower for the same work. Make's paid tiers start at single-digit dollars per month. For a business running a handful of moderately busy scenarios, this is frequently the difference between a bill that rounds to nothing and one you notice.
The catch is that credit accounting is genuinely harder to predict than task counting, because a single scenario run can consume a variable number of operations depending on how many items the iterator found. Build the scenario, run it on real data for a week, then look at the usage graph before you commit to a tier.
Error handling: the feature that justifies the learning curve
This is where Make separates itself, and it is the reason we reach for it on client work more often than the marketing pages would suggest.
Any module can be given an error handler route — a separate branch that runs only when that module fails. That branch can retry, or route to a fallback, or log the failure somewhere a human will see it, or all three. You can also configure a scenario to resume from the point of failure rather than restarting.
Concretely: a scenario that pushes new customers into your accounting system can be built so that when the accounting API is down, the record is parked in a holding table and retried later, and someone gets a message naming the customer that did not sync. Compare that to the default behaviour of simpler tools, which is that the run stops and the record silently does not exist.
For anything touching money, customer commitments or compliance, that difference is not a nice-to-have.
The honest downsides
- The learning curve is real. Routers, iterators, aggregators and data structures take a weekend to become comfortable with, not an afternoon. If nobody on your team wants to spend that weekend, the automation will not get maintained.
- The app directory is smaller than Zapier's. Mainstream tools are well covered; niche industry software often is not. Make's HTTP module can call any API, but that means writing requests by hand.
- Operation forecasting is fiddly. Variable-length iterations make usage genuinely hard to predict in advance.
- Complex scenarios become their own maintenance burden. A forty-module scenario with six routes is a small software system. It needs documentation and an owner, the same as any other.
Choosing between Make and the alternatives
Pick Make when your process has real conditional logic, when you need to loop over lists, when failures must be handled rather than merely reported, and when you want more automation per dollar than Zapier gives at volume.
Stay on Zapier if your integrations are exotic and Make does not support them, or if simplicity matters more than capability. Move to n8n if you want to self-host, if data residency is a compliance question, or if your volume is high enough that per-execution pricing beats per-operation pricing outright.
Make also pairs well with a spreadsheet as its data layer — see using Google Sheets as an automation backbone — and with Slack as the place humans get pulled in for approvals. If you are weighing whether to build this in-house or bring someone in, the questions worth asking any automation agency apply here too.