Make: What It Actually Does in 2026
Make — formerly Integromat, for anyone who's been in this space long enough to remember — is the visual automation platform that occupies the middle ground between Zapier's simplicity and n8n's developer flexibility. It has a genuinely powerful visual builder, an operations-based pricing model that's cheaper than Zapier for complex workflows, and a learning curve that's steeper than it initially appears. As of 2026, it's the strongest option for power users who've outgrown Zapier but don't want to self-host n8n or write JavaScript. That's a specific audience, and Make serves it well.
What It Actually Does
Make builds "scenarios" — visual workflows that connect apps, transform data, and execute logic. Like every tool in this category, the basic pattern is trigger-action: something happens, Make does something about it. What separates Make from Zapier is what happens in between. Make's visual builder includes routers (split the flow into multiple paths based on conditions), iterators (loop through arrays of items), aggregators (collect multiple items back into one), and error handlers — all as visual components you drag onto the canvas and connect. This isn't just a cosmetic difference. It means workflows that would require workarounds or code in other tools are buildable visually in Make.
The canvas itself is Make's strongest feature. Your scenario is laid out as a flowchart — you can see branches, loops, and error paths all at once. Each module shows its configuration when you click it, and you can inspect the data flowing between modules in real time. For someone who thinks visually and wants to understand their automation at a glance, Make's builder is the best in the category. It's not close.
The integration library covers the major apps — Google Workspace, Slack, Airtable, HubSpot, Shopify, Notion, and hundreds more — plus an HTTP module that lets you call any API with full control over method, headers, body, and authentication. The HTTP module is Make's escape hatch: when there's no native integration for your app, you can build one yourself with raw HTTP calls. It works, though it means you're doing API programming through a visual form, which is a mixed experience.
Data transformation is where Make quietly excels. Built-in functions for text manipulation, date math, array operations, and JSON parsing are available in every module's field mapping. You can compose these functions — formatDate(parseDate(1.body.created_at; "YYYY-MM-DD"); "DD/MM/YYYY") — directly in the field editor. It's not code, exactly, but it's closer to writing formulas in a spreadsheet than to the point-and-click mapping Zapier offers. This is more powerful and more confusing, which is a recurring theme with Make.
What The Demo Makes You Think
The Make demo shows a scenario with routers splitting the flow four ways, iterators processing an array, an aggregator collecting results, and a final action posting a summary. It looks like visual programming — and it is, more or less. The impression is that you can build genuinely complex logic without code, and that impression is more accurate for Make than for any competing visual builder.
Here's what the demo doesn't show you.
It doesn't show you the learning curve. Make is not hard in the way n8n is hard — you won't be writing JavaScript. It's hard in the way that any powerful visual tool is hard: there are many components, many configuration options, and the relationships between them aren't always obvious. The difference between a router and a switch, when to use an iterator vs. processing a bundle directly, how aggregators reset — these are concepts you need to learn, and the learning mostly happens through building things wrong and figuring out why.
It doesn't show you the error messages. When a Make scenario fails, the error message is... often not helpful. You'll get a module highlighted in red with a message like "The operation failed" or a JSON blob that describes the API error but doesn't tell you which part of your configuration caused it. Debugging in Make means clicking through modules, inspecting their input and output at each step, and deducing where the data went wrong. The execution history helps — you can replay failed scenarios and step through them — but the initial error reporting is a weak point that hasn't improved as much as you'd hope over the years.
It doesn't show you the pricing arithmetic in detail. Make bills by "operations" — each module execution in a scenario counts as one operation. This is different from Zapier's "task" model in an important way: a five-step scenario that runs once uses five operations on Make, same as Zapier. But Make's operations are cheaper per unit, and Make offers higher volume at lower price points. The free tier gives you 1,000 operations per month [VERIFY]. Paid plans start at $9/month for 10,000 operations [VERIFY]. For multi-step workflows, Make is meaningfully cheaper than Zapier. For single-step workflows, the difference is smaller. The math favors Make as complexity increases — which is convenient, since Make's builder is also better for complex workflows.
What the pricing page buries: some integrations are only available on higher-tier plans. The HTTP module is available everywhere, but specific app connectors might require the Teams or Enterprise tier. Check this before committing to Make for a specific workflow. There's nothing quite like building a scenario and discovering that the integration you need is on a tier above yours.
It doesn't show you what happens at the edges of the visual builder's capability. Make can handle impressive complexity visually, but there's a ceiling. Workflows that need to maintain state across executions, coordinate between multiple scenarios, or implement truly custom logic start straining the platform. Make's answer is the "custom function" module and the ability to call external APIs, but at that point you're working around the visual builder rather than with it. This ceiling is higher than Zapier's and lower than n8n's — which is exactly where you'd expect it for a tool positioned between them.
What's Coming
Make has been steadily expanding its AI capabilities — scenario templates that use LLMs for text processing, built-in AI modules for classification and extraction, and "Make AI" features that help you build scenarios using natural language descriptions. The AI-assisted scenario building is the most interesting development: describe what you want in plain English, and Make generates a draft scenario. In practice, the generated scenarios need significant modification for anything non-trivial, but as a starting point they're faster than building from scratch.
The platform is also investing in team collaboration features, improved monitoring dashboards, and better error handling. These are the right priorities — Make's individual-builder experience is strong, but its team and operational tooling has lagged behind.
What would actually move the needle: better error messages (the single most consistent complaint in the Make community), a simplified mode for users who don't need routers and iterators yet, and more transparent pricing around which integrations are available on which plans.
Should you wait? No. Make is a mature platform that's been production-ready for years. The improvements are incremental — each one makes the tool slightly better, none of them will fundamentally change what it is. If Make fits your needs today, start today.
The Verdict
Make earns its slot as the best visual automation builder for power users. If you've outgrown Zapier — if you need branching, iteration, or complex data transformation and you don't want to write JavaScript — Make is the correct next step. The operations-based pricing is fairer than Zapier's at higher complexity. The visual builder is genuinely more capable. The learning curve is real but not unreasonable for someone willing to invest a few hours.
It is not the right tool for: absolute beginners who want the simplest possible setup (Zapier is easier), developers who want code access and maximum flexibility (n8n or Pipedream are better), or teams with zero budget (Make's free tier is functional but limited). It's also not the right tool if your primary integration needs aren't covered — check the specific modules and actions you need, not just whether the app name appears on Make's integration page.
The honest summary: Make is what you graduate to after Zapier and before n8n. That's not a backhanded compliment — it's a description of a product that genuinely serves its niche. It's more powerful than it needs to be for simple workflows and less flexible than a code-based solution for complex ones. For the surprisingly large number of people whose needs fall between those poles, it's the best option available.
This is part of CustomClanker's Automation series — reality checks on every major workflow tool.