What we do
Tools
Industries
Department
How we workLet's talk →
Home/Make
Make.com automation

Make.com Automation: How Scenarios Run, What They Cost, and How They Fail

A new order lands, a row appears in a sheet, and a Slack message goes out, all without anyone touching it. In Make that's one scenario. Here's how it's built, how Make counts what it costs, and what to set up before the day a module throws an error.

Where Make stops

Complex scenarios on a canvas get hard to maintain once the logic needs to live in real code.

Stuck on Make? Let's solve it →
How a Make automation works

A scenario is the automation. It starts with a trigger module (a new record, a schedule, or a webhook) and runs the modules after it from left to right.

Bundles are the items moving through it. Five new orders are five bundles, and modules after the trigger run once for each.

Credits are what you pay in. They replaced operations as Make's billing unit, and a standard module uses one credit each time it runs. AI modules can use more.

A first webhook scenario that fails safely

  1. 1

    Add a Custom webhook as the trigger

    Create a new scenario Webhooks Custom webhook

    Make gives you a URL. Point the other system at it and send one real example so Make learns the shape of the data.

  2. 2

    Set it to run immediately

    With a webhook trigger, set the scenario's schedule to run as data arrives, so each request is processed when it lands instead of on an interval.

  3. 3

    Add the action modules

    Create the record, update the sheet, post the message. Map fields from the webhook bundle into each one.

    Watch for: arrays. If an order has line items, an Iterator splits them into bundles, and every module after it runs, and costs credits, once per item.

  4. 4

    Attach an error handler to the risky module

    Right-click the module that calls an outside system and add an error handler. Resume carries on with a fallback value, Ignore drops that bundle, Commit and Rollback stop the run, and Break stores the run as an incomplete execution you can retry.

    Watch for: Break only helps if storing incomplete executions is switched on in the scenario settings.

Where the credits go in one order sync

Credits multiply after an Iterator, because everything downstream runs per item. That's why one scenario's bill can climb while order count barely moves.

Example · one order with 4 line items
Webhook trigger receives the order 1
Look up the customer in the CRM 1
Iterator splits the line items 1
Create each line in the order system (Once per item) 4
Adjust stock for each line (Once per item) 4
Credits for this one order 11

Example figures for a standard, non-AI scenario. At 150 orders a day that's roughly 1,650 credits a day, before retries. Make's scenario history shows the real count per run.

Leave it in Make, or move it to code

Leave it in Make

When the scenario is readable and cheap

  • Someone besides the builder can open it and follow the branches.
  • A failure is visible in the history and doesn't cascade into other scenarios.
  • Credit use grows in line with the business, not faster.
Move it to code

When it has become infrastructure

  • Several scenarios hand data to each other and one stalling stops the rest.
  • Logic is spread across nested routers or a stretched function library.
  • Per-item credits on a high-volume flow cost more than running it as a small service.

Most teams keep the bulk of their scenarios in Make and move one or two high-volume or high-stakes flows out.

A subscription business running on a scenario chain

Subscription business · several Make scenarios passing orders between systems

Before

A scenario timed out or hit a limit, the next one never ran, and the gap went unnoticed for days.

After

One service replaced the chain, with proper error handling and a log anyone can read.

A failure now raises an alert instead of a mystery.

Let's talk

One scenario carrying the whole order flow?

n-frames rewrites the scenario your business can't afford to have stall as a small, logged service, and leaves the rest of your Make automations where they are. When a system has no Make app, we build the API or webhook bridge Make can call.

Replace the brittle scenario →

Questions people ask

What is Make (Make.com)?

A visual automation platform, formerly called Integromat. You build scenarios by placing modules on a canvas, with routers for branches and iterators for lists, which handles more involved logic than simple trigger-and-action tools.

What's the difference between Make and Zapier?

Both connect apps without code. Zapier is quicker for straight trigger-and-action jobs; Make's canvas, routers and iterators make branching and list handling easier to see. They also count usage differently, so price the same workflow in both.

How does Make.com pricing work?

Plans come with a monthly allowance of credits, the unit that replaced operations. A standard module uses one credit per run, so a scenario that loops over many items or runs often uses credits fast. Prices change, so check Make's pricing page.

Do you connect Make to other systems, or build Make scenarios for us?

Mostly the first. When a system has no Make app, n-frames builds an API or webhook endpoint Make's HTTP and Webhooks modules can call. When a scenario has outgrown the canvas, we replace that piece with custom code and keep the rest in Make.

What happens when a Make scenario hits an error?

Without a handler, the run stops at the failing module, and repeated errors can switch a scheduled scenario off. With one attached, you choose whether to resume, skip the bundle, roll back, or store it as an incomplete execution to retry.

Let's talk

Tell us the one thing your team does manually that eats up time. We read every message and reply within a day.