VamimiOpen VamimiAI

Automation documentation

Make Error Handlers: Break, Rollback, Commit, Ignore, Resume

What each Make error handler directive does to the run, the bundle and your data, when to use it, and the scenario settings that decide if a failure is lost.

By VamimiAI team · · 4 min read

In Make, an error handler is a route you attach to a module; it runs when that module fails and ends in a directive that decides what happens next. Ignore and Resume let the run carry on, Commit and Rollback stop it, and Break sets the failed bundle aside as an incomplete execution so it can be retried. Which one you pick decides whether a client's order or lead is handled, skipped or lost.

What happens with no error handler

When a module without an error handler fails, the run stops with an error. If the scenario keeps failing, Make switches it off after the number of consecutive errors set in the scenario settings, and every run after that simply does not happen until someone turns it back on.

Two scenario settings matter here, and both are worth checking before a handover:

  • Allow storing of incomplete executions. With it on, a run that fails can be kept and resolved or retried later instead of being lost.
  • Number of consecutive errors. How many failed runs in a row it takes for Make to switch the scenario off.

The five directives

Add an error handler by right-clicking a module and choosing Add error handler, then end the route with one of these:

DirectiveThe runThe failed bundleUse it when
IgnoreCarries on with the next bundleSkippedOne bad record must not stop the rest
ResumeCarries on as if the module had workedReplaced by output you specifyA sensible default value exists
CommitStops, marked as a successNot processed furtherPartial work is fine to keep
RollbackStops, marked as an errorNot processed furtherPartial work must be undone
BreakStops for that bundleSaved as an incomplete execution, retried automatically if you set it toThe failure is likely to pass, such as a timeout

Ignore

The error is swallowed: the bundle that failed is dropped and the scenario goes on. The run looks successful, so nobody will notice the skipped record unless the handler route does something visible first, such as posting to Slack or adding a row to a log sheet before the Ignore.

Resume

You give the output the failed module should have produced, and the run continues with it. Good for optional enrichment (a missing company size becomes "unknown"), dangerous for anything that matters, because the substitute value flows into everything after it.

Rollback vs Commit

Both stop the run. Commit keeps what was already done and marks the run as a success; Rollback reverts the changes made by modules that support transactions and marks the run as an error. Most app modules cannot be undone, so Rollback mainly protects data stores and databases: an email that was sent stays sent.

Break

Break is the safest choice for outside services. The failed bundle is stored as an incomplete execution (this needs Allow storing of incomplete executions on), and with automatic completion turned on, Make retries it after the interval you choose, for the number of attempts you set. If the retries run out, it waits in the list of incomplete executions for someone to resolve.

A sensible default for client scenarios

  1. Turn on Allow storing of incomplete executions for every production scenario.
  2. Give every module that calls an outside service an error handler that ends in Break with automatic retries.
  3. Where skipping a record is acceptable, log it first and then Ignore, so the skip is visible.
  4. Keep Resume for values that are truly optional.

See where a scenario will lose data

The scenario editor shows error handler routes, but not what each one means for the client's data, and it never shows the modules that have no handler at all. Importing the blueprint into VamimiAI's Make scenario diagram draws each error handler route dashed and ends it in what its directive does, in plain words such as "Saved to incomplete runs for a retry". The checks on import flag modules with no error handler and scenarios that do not keep failed runs.

Then create the handover document so the client sees the same picture, with a table of what happens when each module fails. Scenario already switched off, or seeing "not enough space to add a new incomplete execution"? See Make scenario deactivated. Building on n8n as well? The n8n error handling guide covers the same ground there.

Questions

What is the difference between Ignore and Break in Make?

Ignore drops the failed bundle and lets the run carry on, so the record is skipped. Break stops processing that bundle and saves it as an incomplete execution, so it can be retried automatically or resolved by hand.

Why did my Make scenario turn itself off?

Make switches a scenario off after the number of consecutive errors set in its settings. Add error handlers to the modules that fail, and keep incomplete executions so failed runs are not lost.

Does Rollback undo everything the scenario did?

No. Rollback reverts changes only in modules that support transactions, such as data stores. Actions in most apps, like a sent email or a created CRM record, cannot be undone.

Tools for this