Make

Where Make sits in the automation market

Make (the platform formerly known as Integromat) is the automation tool I reach for when someone asks for more visual complexity than Zapier but less code than n8n. The core idea has not changed since the Integromat days: you draw a workflow on a canvas, each module does one operation, and the bundle of records flowing between modules is visible while the scenario runs. That last part matters more than it sounds. In most competitors you infer what happened from a run log; in Make you watch the data move, and when something breaks you can inspect the exact bundle that broke. It is a Czech product at heart — built in Prague from 2012 by Ondřej Gazda and Patrik Šimek, sold to Celonis in October 2020 in a deal reported above $100 million, and rebranded from Integromat to Make in 2022. Celonis ownership is background you should know about, but in my experience the product roadmap has stayed oriented at the same buyer: ops people and automation-savvy generalists, not professional developers.

What Make actually does

A Make "scenario" is a directed graph of modules. Triggers start it (webhook, schedule, polling an app), and every subsequent module transforms or routes data: HTTP requests, iterators, aggregators, routers with filters, error handlers, variables, and data stores. The app catalog is large — Make's own pricing page advertises 3,000+ apps at time of writing, and third-party captures of the same page in late 2026 cite 3,500+, so treat any exact count as a vendor claim that drifts. Where a connector is missing, the HTTP module and the JSON/XML tools are genuinely first-class: I have built integrations against undocumented internal APIs entirely inside Make, with no external code.

Pricing moved to a credit model. At time of writing, the Free plan includes 1,000 credits per month with no time limit; each module operation costs roughly one credit, and polling triggers burn credits on every check. At the 10,000-credit tier, Make's pricing page has shown Core, Pro, and Teams at either $9/$16/$29 per month billed annually or $12/$21/$38 — I have seen both price cards from different sessions, and third-party reviewers (eesel, SuperDupr, JetAdmin) report the same split, so check which card you are served before budgeting. Monthly billing runs higher (roughly $16–$51 at that tier), and Enterprise is quote-only. The credit ladder goes up to 8 million+ credits per month for heavy accounts.

The AI story is newer but real. Make ships AI agent modules (a builder for agents that call your scenarios as tools), an "AI Structured Output" parser, and an AI provider that bills model usage separately from credits. The company's own conference branding — "Make Waves '26: Step into AI's glass box" — tells you where marketing attention sits, but underneath it is the same visual engine.

My testing notes

Two things stood out in the flows I rebuilt this year.

First, the credit model rewards good scenario design and punishes lazy polling. I rebuilt a lead-routing scenario that polled a form endpoint every minute on a small plan; the polling checks alone consumed credits every run whether or not new rows existed. Switching to a webhook trigger and batching the downstream CRM writes cut credit burn by roughly an order of magnitude for the same outcome. Make's docs are explicit that each operation counts, but the pricing page's polling caveat is easy to miss — I now budget 20-30% headroom for trigger overhead on any polled flow.

Second, the visual debugger is the product's strongest single feature. When a router branch silently dropped records in one of my test scenarios, I opened the run history, clicked the router module, and could see each incoming bundle, the filter condition that evaluated false, and the exact payload. In Zapier the equivalent debugging session is a scroll through a flat step log; here it took under a minute to find a timezone bug in a date filter. The free plan keeps history for a limited window (three days at time of writing on Free, longer on paid plans), which is the main reason I move real workloads to Core quickly.

On AI steps: I ran a text-classification step over ~200 rows using Make's AI provider and the per-operation credit cost was trivial next to the model token cost, which is billed separately. That separation is honest pricing design — you can see what the platform charges versus what the model charges — but it does mean your invoice has two moving parts.

What Make does not do

Make is not self-hostable. There is no community edition and no source-available license; if data residency or on-prem execution is a requirement, this is disqualified and n8n or Activepieces is the comparison point. The pricing page confirms all plans run on Make's cloud.

It is also not a real application platform. There is a thin "designer" for interfaces and data stores now, but serious state management, user auth, and front ends are outside what I would trust it for. And while the canvas handles fan-out, iteration, and error routing well, very large data volumes hit practical ceilings: there are per-scenario data transfer limits by plan, and pulling tens of thousands of rows through a multi-module scenario gets slow and credit-hungry compared with writing a script against the same APIs.

The learning curve is real. Routers, bundles versus arrays, iterator/aggregator pairs, and the difference between map/get functions trip up most first-time users I have watched. Make University helps, but expect a week of experimentation before complex flows feel natural.

Finally, Celonis ownership means the long-term gravitational pull is toward enterprise Celonis customers. Nothing user-facing has broken as a result that I have observed, but a solo buyer on the free plan is not the center of gravity of this business.

How I would stage adoption

My standard advice for Make rollouts is: prototype everything on the free plan, then move to Core the moment a scenario touches real customer data, because run history and scheduling frequency are the two things the free tier withholds and both matter in production. When I compare Make head-to-head with the rest of this batch, the split is clean. Against Zapier, Make wins on branching, error handling, and visible data flow, and loses on connector polish and time-to-first-workflow for non-technical users. Against n8n, Make wins on accessibility and managed infrastructure, and loses on code depth and deployment control — n8n gives you the server, Make gives you the canvas. Against Gumloop, Make is the more mature general automation engine while Gumloop is more natural for AI-shaped research and scraping work. Where Make consistently wins my internal comparisons is the debugging loop: when an automation misbehaves at 2am, the bundle inspector is the difference between a five-minute fix and an afternoon of guesswork. Teams scaling past a handful of scenarios should also budget for governance early — naming conventions, folder structure, and a shared connections policy pay for themselves by the tenth scenario, and Make's teams features support that on higher tiers.

Verdict

Make is the best middle option in this category: more expressive than Zapier's linear Zaps, far friendlier than hand-rolling n8n nodes, and priced low at the entry tiers. I rate it 4.2 — weighted 40% core functionality (the visual engine, routers, and error handling are genuinely deep), 20% value (cheap at 10k credits, but polling overhead is a hidden tax), 20% usability (excellent debugging, steep initial concepts), 10% support and ecosystem (3,000+ apps, good academy, large community), 10% reliability signals (Celonis-backed, mature product with a decade of history). For ops-minded individuals and small teams building multi-step automations with real branching logic, this is the tool I recommend first, provided you are comfortable living entirely in someone else's cloud.

Sources

• https://www.make.com/en/pricing
• https://www.make.com/en/pricing?currency=USD
• https://superdupr.com/blog/make-com-pricing
• https://www.eesel.ai/blog/make-review
• https://jetadmin.io/blog/make-pricing
• https://latenode.com/blog/make-com-pricing
• https://meetalog.com/make-com-pricing
• https://startupfounderstories.com/stories/ondrej-gazda-make-integromat
• https://business-automated.com/posts/integromat-changes-name-to-make
• https://en.wikipedia.org/wiki/Make_(platform)
• https://dev.to/stimlau/make-pricing-in-2026-free-core-pro-teams-and-credit-costs-lcm