What Is Make (Formerly Integromat) and Who Is It For?
Make is a visual workflow automation platform that lets you connect apps, move data between them, and trigger actions based on conditions — all without writing production code. I first picked it up when a client needed something more flexible than Zapier but did not have a developer on staff. Three years later it is still running about a dozen automations that touch their CRM, invoicing, and content pipeline daily.
If you are evaluating Make for your small team or freelance practice, here is an honest picture of what it does well, where it falls short, and whether the learning curve is worth it for your situation.
Quick Picks (TL;DR)
- Best for: Small teams and technically comfortable freelancers who need multi-step automations with conditional logic, data transformation, or multiple branching paths.
- Skip it if: You need something working in 20 minutes with no learning curve — Zapier's simpler interface will get you there faster.
- Sweet spot: 3-15 step automations that would require a developer to build in code but are too complex for basic if-then tools.
Make vs. Competing Platforms
| Tool | Best for | Free plan | Starting price | Standout |
|---|---|---|---|---|
| Make | Complex multi-step workflows, data transformation | Yes (1,000 ops/mo) | ~$9/mo (verify) | Visual canvas, iterators, routers |
| Zapier | Quick two-step automations, non-technical users | Yes (100 tasks/mo) | ~$19.99/mo (verify) | Ease of use, app breadth |
| n8n | Developer-friendly, self-hostable | Yes (self-host free) | ~$20/mo cloud (verify) | Open source, code nodes |
| Power Automate | Microsoft 365 shops | Yes (with M365) | ~$15/mo (verify) | Deep Office integration |
| Pipedream | Developer-first, code-heavy | Yes | ~$19/mo (verify) | Full Node.js code steps |
What Make Actually Does
Make uses a canvas-based editor where you drag modules onto a visual board and connect them with lines. Each module represents an app action (send a Gmail, create a Notion page, update an Airtable record) or a logic operation (filter, router, iterator, aggregator). You can see the entire flow at once — which is both its biggest advantage over Zapier and the source of its steeper learning curve.
The core building blocks you will use constantly:
Triggers: The event that starts a scenario — a new form submission, a scheduled time, a webhook firing from another app, a new row in a spreadsheet.
Modules: Individual steps. Make has connectors for over 1,000 apps (verify). Most have both "watch" (trigger-style) and "action" variants.
Routers: Split the flow based on conditions. One branch handles paying customers; another handles free users. This is where Make pulls ahead of simpler tools — Zapier's free and lower tiers only support linear flows.
Iterators and aggregators: Process arrays of data item by item, then recombine results. Essential for anything involving lists — processing all the line items in an order, looping through a list of contacts, collecting results before sending one summary email.
Error handlers: Define what happens when a module fails — retry, ignore, or route to a separate recovery flow.
Who Make Is Actually For
After using it across a range of projects, the profile that makes the most sense for Make is: someone comfortable with logic but not necessarily a software engineer. You need to understand what an array is, why filters matter, and how data mapping works between fields. You do not need to write code — but if the concept of "iterating through a list" is unfamiliar, expect a few frustrating hours before things click.
Small marketing and operations teams building multi-step workflows around CRM data, lead routing, or content publishing get strong value. The visual canvas makes it easier to audit and hand off workflows than a script would.
Freelancers managing client operations who build automations as a deliverable — I know several operations consultants who build Make scenarios as their primary service offering — find the tool economical because the free tier is generous and the per-operation pricing stays low on moderate volume.
E-commerce teams handling order processing, inventory sync, and customer notification flows across Shopify, Airtable, and communication tools. Make's iterator support handles the "for each line item in this order" logic that breaks basic automation tools.
Solo founders who want to automate their own back office — lead follow-up, invoice generation, content scheduling — and are willing to invest a few hours upfront to save recurring manual time.
Honest Pros
- Visual canvas is genuinely better for complex flows. Being able to see all your branches, routers, and error paths on one screen is a real advantage when debugging or handing off to a colleague.
- Generous free tier. 1,000 operations per month covers a surprising amount of moderate-volume automation at no cost.
- Data transformation is built in. Make has a rich set of built-in functions for string manipulation, date formatting, number math, and array operations without needing a code step.
- Pricing scales reasonably. Unlike Zapier, which charges per task and gets expensive quickly on multi-step Zaps, Make charges per operation across all scenarios, which often works out cheaper for equivalent functionality.
- Webhook support on free tier. Many tools gate webhooks behind paid plans. Make includes them for free.
Honest Cons
- The learning curve is real. The first time you encounter iterators or aggregators, you will probably break your scenario and spend time staring at data structure diagrams. Plan for a few hours of learning investment before you are productive.
- Debugging is clunky. When a run fails partway through, finding exactly which module failed and why requires clicking through execution history. It is manageable but slower than the near-instant feedback loop of a native code environment.
- App ecosystem is smaller than Zapier's. Make has over 1,000 connectors (verify) but Zapier has more, and some niche tools only have Zapier integrations. The HTTP module fills the gap for anything with an API, but that requires more setup.
- Scenario organization gets messy at scale. If you end up with 50+ scenarios, the folder system works but is not as sophisticated as a proper project management tool. Teams with large automation libraries often need a naming convention system just to stay oriented.
- AI and agent features are newer. Make has added AI modules and agentic capabilities, but as of mid-2026 they are less mature than n8n's AI agent node. If AI-powered automation is your primary goal, n8n may be a better fit.
When to Pick Make Over the Alternatives
Choose Make over Zapier when your workflows have more than two or three steps, involve conditional branching, or require transforming data between formats. The per-operation pricing also tips in Make's favor once you have more than a handful of active multi-step automations.
Choose Zapier over Make when speed of setup matters more than flexibility, when your team is non-technical and needs to maintain the automations themselves, or when you need a connector that only exists on Zapier's marketplace.
Choose n8n over Make when you want to self-host for data privacy reasons, need to write custom JavaScript logic, or are building AI agent workflows where n8n's LangChain integration gives you more control.
A Typical Make Use Case (What I Built)
One of the first scenarios I built that made me a believer: a new deal reaches a specific stage in Pipedrive, Make fires a webhook. It then checks whether the deal value is above a threshold (router), fetches additional company data from Clearbit (HTTP module), creates a project in Asana with a templated task list (iterator), sends a Slack message to the account owner with a formatted summary, and logs everything to a Google Sheet row.
That is a six-module scenario with a router, an HTTP call, and an iterator. In Zapier, that would require a paid plan and multiple Zaps chained together. In code, a developer would spend half a day on it. In Make, a technically comfortable non-developer can build and maintain it.
Verdict
Make is the right tool for small teams and freelancers who have hit the ceiling of simple two-step automation tools and are not ready (or willing) to write code. The visual canvas, generous free tier, and sophisticated data handling make it a strong middle ground between drag-and-drop simplicity and full code flexibility. Just budget for a real learning investment upfront — the payoff comes after you clear the conceptual hurdles around iterators, routers, and data structures.
If that sounds like too much: Zapier. If you want more code control and are comfortable in a terminal: n8n.
FAQ
Is Make the same as Integromat? Yes. The platform was rebranded from Integromat to Make in 2022 after being acquired by Celonis. The core functionality is the same; existing Integromat users migrated to the Make platform.
Is Make free? Make has a free plan that includes 1,000 operations per month and most core features including webhooks and multi-step scenarios. Paid plans start at around $9 per month (verify) for 10,000 operations.
How does Make pricing work? Make charges per operation — each module execution in a scenario counts as one operation. A five-step scenario that runs 200 times consumes 1,000 operations. This is different from Zapier's per-task model and is often cheaper for equivalent automation volume.
Can Make handle AI automation? Make has modules for OpenAI and other AI services, so you can include LLM calls as steps in your scenarios. The AI capabilities are functional but less deeply integrated than n8n's native AI agent nodes. For AI-heavy workflows, n8n is currently the stronger platform.