Make

Make is the visual automation platform teams graduate to when linear, per-task automation stops being enough. Instead of a vertical list of steps, you build a scenario on a canvas: triggers feed modules, routers split the flow down conditional paths, iterators walk arrays item-by-item, aggregators recombine the results, and error handlers keep the whole thing running when an API misbehaves. Billing is per operation rather than per task, which is the single biggest reason high-volume workflows usually cost far less here than on Zapier.

Best for

• Ops and RevOps teams automating processes with real conditional branching.
• High-volume workflows where per-task pricing has become the dominant cost.
• Technical marketers who want API-level power without writing a service.
• Agencies running many client automations from one workspace with teams and roles.
• Teams adding AI steps — classification, extraction, drafting — inside existing processes.

Not ideal for

• Complete beginners who want a two-step automation and nothing more (Zapier is gentler).
• Teams that require self-hosting or full data residency control (choose n8n).
• Engineering teams who would rather write code-first workflows (choose Pipedream).
• Buyers who need the very longest tail of niche SaaS connectors (Zapier still leads on catalogue size).

What Make actually is

Make began life as Integromat and kept that engineering heritage: it is a dataflow tool with a friendly face. Each module is a typed operation with an input bundle and an output bundle, and mapping between them is explicit. That explicitness is what makes multi-branch business logic practical — you can see, on one canvas, what happens when a payment fails, when a record already exists, or when a webhook arrives with a missing field.

The building blocks that matter in practice are routers (conditional branches), filters (per-path conditions), iterators and aggregators (array handling), data stores (persistent state between runs), webhooks (instant triggers), and error handlers with configurable retry and break/resume behaviour. Very few automation platforms give you all of those without dropping into code.

Pricing and the operations model

Make charges operations, not tasks. One operation is roughly one module execution, so a scenario with six modules that runs 1,000 times consumes about 6,000 operations. The free tier includes 1,000 operations a month — enough to build and validate a real workflow before paying. Core sits at about $10.59/mo, Pro at about $18.82/mo (adding full-resolution execution logging, custom variables and priority execution), Teams at about $34.12/mo for shared workspaces and roles, and Enterprise is quoted. Always confirm current numbers on the Make pricing page — automation vendors re-price often.

Make AI and AI Agents

Make's AI surface has two halves. The first is AI-as-a-module: OpenAI, Anthropic and other model providers appear as ordinary modules, so classification, extraction, summarising and drafting slot into existing scenarios with the same mapping and error handling as any other step. The second is Make AI Agents, where the agent decides which tools to call rather than following a fixed path — useful for triage, research and support flows where the branching is genuinely open-ended.

Our editorial position: use deterministic scenarios for anything with money or compliance attached, and reserve agentic execution for judgement-heavy steps where a wrong turn is recoverable. The strength of Make is that both live on the same canvas, so you can wrap an agent in deterministic guardrails instead of choosing between the two.

Integrations

The app catalogue runs to thousands of services across CRM, ecommerce, finance, marketing, support and data tooling. More important for serious builds is the generic HTTP module: any REST API with documented auth becomes usable, and Make's custom app framework lets you package it properly for reuse. In practice that means "does Make integrate with X" is nearly always yes — the real question is whether the native connector exists or you build the request yourself.

Make vs the alternatives

• vs Zapier — Zapier is easier on day one and has the broadest catalogue. Make wins on logic, visual clarity and unit cost at volume.
• vs n8n — n8n wins if you need self-hosting, source control and code nodes. Make wins on polish, managed reliability and time-to-first-working-scenario.
• vs Power Automate — Power Automate is the default inside a Microsoft 365 estate. Make is the better general-purpose platform once your stack spans many non-Microsoft SaaS tools.
• vs Pipedream — Pipedream is code-first and excellent for developers. Make keeps non-engineers able to read and maintain the workflow.

Practical pitfalls

• Unfiltered triggers burn operations — filter as early in the flow as possible.
• Iterators inside iterators multiply cost fast; aggregate before writing.
• Without error handlers, a single 429 can silently halt a business process.
• Scenario sprawl is real — name scenarios by process, not by app, and document owners.

The Tool Money Lab verdict

Make is our recommended automation platform for teams whose processes have branches. It is not the easiest tool to learn, and it should not be the first automation tool a non-technical team touches — but it is the one that still fits when the workflow gets complicated and the volume gets real. The combination of a genuinely readable canvas, operations-based pricing and AI modules on the same surface makes it the most versatile pick in the category. Start on the free tier, build one real process end-to-end, then move to Core or Pro when the operations count tells you to. Make's free plan is enough to prove the case before you spend anything.