Make, formerly Integromat, is where I send people who hit the wall with Zapier. Usually it is one of two walls: the per-task pricing that climbs faster than expected, or the flat, linear logic that makes a complicated workflow painful to express. Make answers both. It gives you finer control over how an automation runs and costs less per unit of work, which is why it has become my default recommendation for anyone whose automations have grown past simple two-app plumbing.
The visual scenario builder
The canvas is the thing that sets Make apart, and it changes how you think about a workflow. Instead of a vertical list of steps, you lay modules out on a grid and draw the connections between them. Each module is a single action: read a row, send an email, parse JSON, call an API. You see the whole scenario at once and follow the path data takes through it. When something breaks, the run history shows the exact module that failed and the data that flowed into it, so debugging means reading the canvas rather than guessing.
That visibility now extends to Make's AI features. Make AI agents and the Make Grid let you build and watch agentic workflows on the same canvas, so you can see the steps an agent takes and where it makes a decision rather than trusting a black box. When an agent is acting on your behalf, seeing exactly what it did is the difference that matters.
Complex logic and data transformation
This is where Make earns its keep. The Router module lets a single scenario fan out into multiple paths based on conditions, so one trigger can do different things depending on the data. Filters sit on the connections between modules and quietly drop anything that does not meet your criteria. Iterators and aggregators let you loop over arrays and then collapse the results into a single bundle, the kind of operation that turns into a tangle of extra steps elsewhere.
Make also gives you a real library of functions for reshaping data inline: parsing dates, splitting strings, doing math, mapping fields from one shape to another. I lean on these constantly when an API hands back data in a format the next app does not expect. The messy automations are where Make pulls clearly ahead, like syncing leads across CRMs that disagree about field names or chewing through nested JSON from a webhook. When an automation has to make decisions and transform data rather than just pass it from A to B, this is the better tool by a wide margin.
Pricing and what you actually get
This is where Make wins on paper, and the math holds up in practice. The Core plan runs roughly $10 to $12 per month for 10,000 operations, around half the per-operation cost of Zapier's comparable tier. The reason that gap matters is that Make counts operations, not tasks: every module run is one operation. For automations that touch several modules per trigger the volume adds up, but the lower unit price still leaves you ahead of Zapier on the same workload. Unused operations roll over for one month on paid plans, which softens the sting of a spiky month.
The free plan gives you 1,000 operations and two active scenarios, enough to build something real and watch it run but not enough to run a business on, so treat it as a proving ground. One more option if you are early-stage: Make runs a startup program that gives eligible companies up to six months free with full access, a genuinely useful on-ramp if you are assembling your stack before you have revenue.
Where it falls short
The power comes with a steeper learning curve. Your first few scenarios take longer to build than the equivalent Zaps, and the canvas can feel intimidating before the model clicks. Concepts like bundles, iterators, and aggregators are not hard once you understand them, but nobody arrives knowing them, and the docs assume more than a true beginner has. Budget an afternoon to get comfortable.
The integration library is the other tradeoff. It has grown past 3,000 apps, which covers the mainstream, but it is still smaller than Zapier's catalog, and the long tail of niche apps is where you feel the difference. Before you commit, check that the tools you depend on have a native Make module. If one does not, you can fall back to a generic HTTP module and call the API directly, but that pushes you into reading API docs.
Who it's for
Make fits people who have outgrown Zapier or who need complex logic without paying a premium for it. Marketing ops teams running multi-step lead routing, agencies managing automations across many client accounts, and technically comfortable small teams all land here naturally. The common thread is caring about cost per operation and wanting genuine branching logic. If you only need simple two-app connections and want the largest integration catalog with the gentlest onboarding, Zapier is still the easier pick, and there is no shame in starting there and migrating once your workflows get hairy.
Getting the most out of it
Add a Router module early, before you think you need it. Routing for different conditions up front means you can extend a scenario later without tearing it down and rebuilding. The people who lose the most time are the ones who build a clean linear scenario, then try to bolt conditions onto it once requirements change. A second habit that pays off: turn on error handling per module instead of letting a single failed step kill the whole run. Make lets you attach a fallback route so a transient API hiccup retries or routes around the problem. Build that in from the start and your scenarios survive the real world, where APIs go down and data arrives malformed more often than the demo suggests.
