Skip to content
Tutorials Center
My learning

Topics

Lesson 26 of 36 ยท Alternatives: Make and n8n

Make: Scenarios, Modules and Bundles

Learn how Make works compared with Zapier: scenarios, modules, bundles and operations, routers and filters, iterators and aggregators, plus a runnable bundle simulator.

Zapier is not the only tool in this space. Make (formerly Integromat) is a visual automation platform that many teams choose when workflows get complicated: it draws the automation as a canvas of connected circles and gives you fine control over data. If you understand Zapier, you already know most of the ideas; the main job is learning Make's vocabulary and how it differs in data flow and pricing.

Neither product runs on this site, so this lesson describes the interface in words (menu names can change between releases) and uses JavaScript stand-ins to demonstrate the concepts, especially bundles, the idea that surprises Zapier users most.

The vocabulary side by side

Zapier Make Notes
Zap Scenario One automation, drawn on a canvas
Trigger Trigger module (first module) Can be a webhook, a watch module, or a schedule
Action Module Each app operation is a circle
Task Operation Make counts every module run per bundle
Paths Router with filters Branches visible as lines on the canvas
Looping, Line-item tools Iterator and Aggregator Split a list into items, then merge back
Tables Data store Simple key-value storage inside Make
Zap history Execution history Per-run logs, with data you can inspect

Scenarios, modules and the canvas

A scenario starts with a trigger module and continues with other modules joined by lines. You build it left to right: click the big plus, search an app, choose an operation (for example Watch Records, Create a Row, Make an API Call), connect your account, and map fields. Every module has a small numbered circle, and the numbers appear in the mapping panel so you can pick data from "module 3" in a later module.

Scenario scheduling is explicit. In the bottom bar you choose Run once, Immediately (for webhook-style triggers), or an interval such as every 15 minutes. Scenarios can be switched on and off, and the Run once button is a great testing tool because it runs on real data and shows you the data that went through each module as a bubble above it.

Bundles: Make's big idea

In Zapier a trigger produces one record per run. In Make a module produces bundles: a bundle is one package of data. A module that finds 10 new rows outputs 10 bundles, and every later module runs once per bundle, automatically. There is no explicit loop to write. That is powerful, but it explains two things:

  • Costs: each module execution per bundle is an operation. A scenario with 4 modules processing 10 bundles costs about 40 operations.
  • Surprises: a Create Row after a module that returns 10 bundles creates 10 rows, whereas the same layout in Zapier would create one.

The stand-in below simulates this flow so you can count operations.

JS Stand-in: bundles and operations

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The filter let only three of five bundles through, so the two later modules ran three times each. Filtering early keeps operation counts low, a theme that comes back in Task Usage and Cost Control.

Routers, filters and error handlers

A router is a special module with several outgoing lines. Each line can have a filter (a condition such as "amount greater than 100"), and bundles flow along every route whose filter matches, or only along a fallback route if you mark it so. This is Make's answer to Zapier Paths. Routes run in the order shown by their small numbers.

Any module can have an error handler attached by right-clicking it and choosing Add error handler. The main directives are:

  • Ignore: skip the failed bundle and continue.
  • Resume: substitute fixed output and carry on.
  • Rollback: undo the scenario's changes where supported and stop.
  • Commit: keep what was done and stop cleanly.
  • Break: store the failed bundle as an incomplete execution so you can retry it later, optionally with automatic retries.

Break plus retries is Make's version of Zapier's replay feature (Error Handling and Replays).

Iterators and aggregators

When one bundle contains an array (an order with items) you often need one bundle per item. The Iterator module takes the array and emits a bundle for each element. After processing you can put things back together with an Aggregator (Array aggregator, Text aggregator, Numeric aggregator for sums and averages, Table aggregator for grids). The aggregator needs a source module, the module whose bundles it should group, so Make knows where each group begins.

JS Stand-in: iterator then aggregator

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Other things Make has

  • Data stores: built-in key-value tables for state and dedupe.
  • Functions in mapping fields: formatDate(), replace(), split(), if(), and many more, typed straight into any field.
  • Make an API Call: a module that sends any HTTP request through an existing app connection, so authentication is reused.
  • Webhooks: Custom webhook modules that catch requests and learn the structure from a sample.
  • Scenario inputs, sub-scenarios and templates to reuse parts.
  • Teams and organisations with roles for managing access.

Plan names, prices and limits for both Make and Zapier change often. This course describes concepts; always check the vendor's current pricing page before deciding.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. A Make module finds 8 rows. How many times does the next module run by default?

    Make passes each bundle through later modules separately, so no explicit loop is needed.
  2. 2. What do you use in Make to turn one array into several bundles?

    The iterator emits one bundle per array element; the aggregator does the reverse.
  3. 3. Which error directive keeps the failed bundle so it can be retried later?

    Break stores the bundle as an incomplete execution that you can retry.
  4. 4. How do you keep operation counts low in Make?

    Every later module runs once per bundle, so removing bundles early saves operations.

Summary

  • Make's scenario = Zapier's Zap; modules are steps; operations are the billing unit.
  • Modules output bundles and later modules run once per bundle: powerful, but watch the counts.
  • Routers with filters branch, iterators and aggregators split and merge lists, error handlers decide what happens on failure.
  • Data stores, functions in fields and "Make an API Call" cover state, formatting and custom endpoints.

Next: n8n: Workflows and Nodes