Make logo

Make

✓ Verified

Visual automation for everyone

Visit Make →

About Make

Make — the product formerly called Integromat — is a hosted automation platform built around a visual canvas. You place modules, connect them with lines, and watch data move through the chain. It sits between Zapier's simplicity and n8n's engineer-friendliness: more powerful than the first, far less setup than the second.

Common questions

How does Make's operation pricing work?
One operation = one module processing one piece of data. A 5-module scenario handling 1 record = ~5 operations. The same scenario with 100 records = ~500 operations (each module runs 100 times). This multiplies fast with Iterators and loops. Make's per-operation price is lower than Zapier's per-task price, but scenarios that fan out (process arrays, handle batch data) consume operations rapidly. Filter early and aggregate before bulk writes to control costs.

What's the difference between Make and Zapier?
Make offers a visual canvas for complex data transformation, branching and iteration that Zapier's linear model can't match. The Iterator/Aggregator pattern handles batch processing elegantly. Zapier is simpler with a larger app library. Choose Make when you need to transform data, handle arrays, or build complex branching logic. Choose Zapier for simplicity and broader integrations.

Do I need technical skills to use Make?
Basic understanding of data structures (arrays, objects, JSON) helps significantly. Make's visual interface is approachable, but working with Iterators, Aggregators and mapping complex data requires conceptual understanding beyond simple trigger-action flows. It's easier than coding, harder than Zapier. Most users become productive within a week of practice.

Can Make handle high-volume workflows?
Yes, but operation accounting matters. Scenarios processing thousands of records daily work well if you aggregate smartly (batch 1,000 rows into one API call rather than 1,000 individual calls). The visual canvas also helps debug and optimize high-throughput flows because you can see exactly where operations are spent. Plan for operation limits per tier when designing batch workflows.

Operations: the one thing to understand before you sign up

Make bills in operations, and almost every surprise invoice traces back to misunderstanding this.

One operation is roughly one module doing one piece of work on one piece of data. Not one scenario run. Not one automation. One module, one item.

Work through what that means:

  • A 5-module scenario triggered once, handling one record: about 5 operations.
  • The same 5-module scenario where the trigger returns 100 records: each downstream module runs 100 times, so roughly 500 operations.
  • Add an Iterator that splits one record into 20 line items, with 3 modules after it: that branch alone is about 60 operations per record.

This is why people arrive from Zapier expecting a cheaper bill and sometimes get a worse one. Zapier does not charge for its trigger or its filter steps; Make charges for essentially every module. Make's per-operation price is lower, so for narrow scenarios it genuinely does win — but the moment your data fans out, the multiplication is brutal.

Two practical defences:

  • Filter early. A filter placed before the expensive modules stops operations being spent on records you were going to discard anyway.
  • Aggregate before you send. If you are writing 100 rows to a sheet, an Aggregator that batches them into one call costs far less than 100 individual writes.

Bundles are the concept that actually takes time to learn

Make's documentation calls the units of data flowing between modules bundles. The learning curve is not the drag-and-drop interface — that part is genuinely easy. It is understanding what happens when one bundle becomes many, or many become one.

Three modules do this work, and you will use them constantly:

  • Iterator takes one bundle containing an array and splits it into separate bundles, one per array element. Use it when an order arrives with a list of line items and each needs handling individually.
  • Aggregator does the reverse: many bundles in, one bundle out. Use it to collect results before a single write, or to build one summary email from many records.
  • Router splits the flow into branches, each with its own filter, so different record types take different paths.

Getting Iterator and Aggregator pairings right is most of the skill in building Make scenarios. Until the model clicks, you will build things that work on one test record and behave strangely on five.

Error handling is better than most people realise

This is Make's quietly strong feature, and it is under-used. Attach an error handler to a module and you choose explicitly what happens on failure:

  • Resume — substitute a fallback value and carry on.
  • Ignore — discard the failing bundle, keep processing the rest.
  • Break — park the failing bundle in the incomplete-executions queue so it can be retried later, by hand or automatically.
  • Rollback / Commit — control whether the whole run is treated as a transaction.

Break plus stored incomplete executions is the pattern worth knowing. It means a third-party API being briefly down does not silently lose your data; the bundles wait for you. Very few automation tools at this price point give you that.

Patterns it handles well

Order and invoice processing. The shape Make is best at: an order arrives containing nested line items, an Iterator splits them, each gets looked up and transformed, an Aggregator assembles the result, one write goes out.

Multi-condition routing. A Router with filtered branches expresses "if it is this kind of record, do this; otherwise do that" far more clearly than chains of nested conditions.

Data reshaping between mismatched systems. Make's built-in functions — string, date, math, array — plus the mapping panel let you fix format mismatches without writing code. Date handling in particular is better than you would expect.

Connecting anything with an API. The HTTP and Webhook modules mean a service with no dedicated Make app is still reachable. Webhooks are queued, so a burst of inbound traffic does not drop requests.

Small amounts of state. Data Stores give you a simple key-value table inside Make. Useful for deduplication — remembering which IDs you have already processed — without standing up a database.

Where it gets hard

  • Debugging deep scenarios. When something goes wrong twelve modules in, you are clicking through bundle inspectors trying to find where the shape changed. It works, but it is slow, and it gets worse the bigger the scenario.
  • The canvas stops scaling. Past roughly twenty modules, the visual layout that made Make approachable becomes the thing making it hard to read. Split into smaller scenarios joined by webhooks before that point.
  • Silent type coercion. Make will happily turn a number into a string and back. Mostly helpful, occasionally the source of a bug that only appears on certain records.
  • Operations accounting is unintuitive. Covered above, but worth repeating as the top cause of regret.

Who it suits

Make is the right pick if you want real branching, iteration and error control without running infrastructure, and if your scenarios are more complicated than "when X happens, do Y". Power users who outgrew Zapier's linear model but do not want to own a server are precisely its audience.

Choose Zapier instead if your automations are genuinely simple, or if you need an integration Make does not have — Zapier's app library is still the largest. Choose n8n if your work is high-volume batch processing, where per-execution pricing beats per-operation pricing by a wide margin, and you have the technical capacity to self-host.

One last caution: pricing, operation allowances and plan limits on all of these platforms change regularly. Model your own expected operation count against the vendor's current pricing page before committing to an annual plan.

Best For

Power users building complex multi-step automations

✅ Pros

  • +Visual scenario builder
  • +Advanced logic and error handling
  • +Generous free tier

❌ Cons

  • -Steeper learning curve than Zapier
  • -UI can be overwhelming

Quick Info

Pricing
freemium
Starting at
$0/mo

Tags

visual-builderautomation
Share:

Stay in the loop

Get weekly picks of the best no-code tools — straight to your inbox.

Frequently Asked Questions about Make

What is the pricing for Make?

Make offers a freemium pricing model, starting at 0/month.

What category does Make belong to?

Make belongs to the Workflow Automation, API Connectors, Automation Platforms categories.

What are the best alternatives to Make?

Check out our workflow automation category to discover the best alternatives to Make.