Make review

Make is a visual automation platform for building workflows and AI agents that connect apps, data sources, and AI models. Per the product page, you can build by dragging and dropping blocks, by prompting in plain language, or by running automations through an MCP server from Claude, ChatGPT, or Gemini.

The platform sits in the same category as Zapier and n8n — one Reddit thread asking for alternatives to exactly those three tools (plus Power Automate, relay.app, and ActivePieces) treats Make as the established benchmark rather than the underdog, which says something about its market position.

Beyond basic scenario-building, Make adds observability across your connected stack, role-based governance controls, and custom code steps in JavaScript or Python for teams that need to fine-tune logic beyond what drag-and-drop blocks allow. AI Agents let you set goals, hand over tools, define limits, and inspect the agent's reasoning rather than treating it as a black box.

Make's core strength, per its own pricing and feature pages, is depth for teams that outgrow single-purpose automation tools.

• Multiple build paths: prompting, visual drag-and-drop, or MCP-driven automation from Claude, ChatGPT, or Gemini — useful if different people on a team work differently.
• Custom code when blocks aren't enough: JavaScript or Python steps let technical users bypass no-code limits instead of hitting a wall.
• Observability across the whole stack, including third-party resources, which matters once you have dozens of scenarios running and need to know what broke and where.
• Governance built in: role-based access controls aimed at departments and full enterprises, not just solo builders.
• Scenario headroom on paid plans: Core unlocks unlimited active scenarios and a 40-minute max execution time, versus the Free plan's 2 scenarios and 5-minute cap, per the pricing page.

That combination — build flexibility plus governance plus observability — is why Make keeps coming up in the same breath as Zapier and n8n in Reddit comparison threads, even when posters are specifically asking for something else.

Make runs on a credit system, and the free and entry tiers are tight. The Free plan caps out at 1,000 credits per month, 2 active scenarios, a 15-minute minimum interval between runs, and just 7 days of execution log storage, according to the pricing page. That's workable for testing, not for running a business process.

Core, at $16/month billed monthly or $12/month billed annually, raises the ceiling to 10,000 credits (scalable to 300,000) and unlimited scenarios, but the monthly-vs-annual price gap is real: the pricing note explicitly flags that monthly billing lists higher per-month prices than annual billing.

Pro, at $28/month or $21/month annual, still starts at the same 10,000-credit base tier as Core — what you get beyond that base isn't published. Add-on pricing for extra credits or API capacity also isn't published anywhere we could find.

One Reddit thread looking for Zapier/Make/n8n alternatives surfaced relay.app specifically for being more intuitive, with one commenter saying it took about 5 minutes to get the hang of it — an implicit nod that Make's build-by-prompting-or-code flexibility comes with more of a learning curve than simpler tools.

Make's pricing page lists a Free plan at $0, capped at 1,000 credits a month, 2 active scenarios, and a 15-minute minimum interval between runs. That's enough to test the platform, not run a business on it.

Core starts at $12/month billed annually ($16 month-to-month) and lifts the scenario cap entirely, with 10,000 credits scalable to 300,000. Pro runs $21/month annually ($28 month-to-month) and keeps the same 10,000-credit base tier, though the pricing page doesn't publish what else separates it from Core beyond "unlimited users."

Two gotchas. First, the billing note on the pricing page confirms monthly billing costs more than annual — budget for the lower annual rate before you commit, or expect a higher bill. Second, credits are the real currency here: scenario counts and user seats matter less than how many operations you burn, and add-on pricing for extra credits isn't published anywhere we could find.

Moving onto Make means rebuilding scenarios from scratch — the platform doesn't publish an automated importer for Zapier, n8n, or other builders' workflows. Expect to recreate each automation by hand, mapping triggers and actions app by app.

The credit system is the bigger adjustment. Unlike flat per-task pricing elsewhere, Make meters by credits consumed per operation, so teams moving from a simpler flat-rate tool need to estimate monthly volume before picking a plan, since underestimating means an unplanned upgrade.

Lock-in risk sits in the scenario logic itself: custom JavaScript or Python steps, MCP server connections, and role-based governance setups are Make-specific and won't port cleanly to another platform if you leave. The pricing page doesn't detail bulk export options for scenario configurations, so document your workflows separately if you're testing Make against alternatives before committing budget.