Choose a Make.com error handler by deciding what should happen to the failed bundle and any changes already made: Skip drops it, Retry saves it for another attempt, Resume sends a substitute output downstream, and Commit or Rollback stop the scenario while keeping or reverting supported transactional changes.
Compare the five Make error handlers
| Handler | Failed bundle | Scenario behavior | Best suited to |
|---|---|---|---|
| Skip | Dropped from the flow | Other bundles continue; Make marks the run successful | Cases where losing the bundle is acceptable |
| Retry | Stored as an incomplete execution with its error, inputs or mappings, and remaining steps | Other bundles continue; the run ends with a warning. The stored work can be completed automatically or manually, depending on configuration. | Temporary faults or work that must not be silently lost |
| Resume | Continues with replacement output you define | Downstream steps run; Make marks the run successful | A safe fallback can stand in for the failed module’s output |
| Commit | Does not proceed through remaining modules | Scenario stops with a warning; prior changes made by supported transactional modules are committed | Earlier transactional changes should remain, but later work must stop |
| Rollback | Does not proceed through remaining modules | Scenario stops with an error; supported transactional changes may be reverted, subject to Auto-commit | Data integrity requires reverting supported changes |
These outcomes follow Make’s overview of error handling. A successful status after Skip or Resume does not mean the original operation succeeded: the failed bundle was either discarded or replaced.
Choose based on the consequence of failure
- Can this record be lost? Use Skip only if dropping the failed bundle is acceptable.
- Could another attempt work? Use Retry when the fault may be temporary or the bundle needs later completion.
- Can a defined fallback safely satisfy later modules? Use Resume only if downstream mappings and actions behave correctly with that substitute.
- Should earlier transactional changes remain or be undone? Choose Commit to keep supported changes, or Rollback to reverse supported changes; both stop the scenario.
Before choosing Commit or Rollback, check whether the modules involved support transactions and how Auto-commit is set. A handler cannot reverse an external side effect merely because it appears earlier in the scenario.
What each handler does
Skip: discard the failed bundle
Skip removes the bundle that triggered the error and lets processing continue with other bundles. Make says it marks the run successful despite the error. It can suit a rejected duplicate signup or another record that is safe to omit, but it is risky for orders, billing, access control, or any workflow where every record matters. Make’s explanation is in its Skip error handler guide.
Retry: preserve the work for another attempt
Retry takes the failed bundle out of the active flow and stores it as an incomplete execution, including the error message, inputs or mappings, and the scenario steps still to run. Other bundles can continue. Depending on configuration, Make can attempt completion automatically or leave it for manual resolution. The Retry handler requires Store incomplete executions to be enabled.
Make also says ConnectionError and RateLimitError are retried automatically when incomplete executions are enabled, so a custom Retry handler is not required solely for those two error types. Retrying will not fix persistent invalid data: correct the cause before replaying the execution. Make’s Retry-specific behavior and configuration are described in its Retry error handler guide.
Resume: provide substitute output
Resume replaces the failed module’s output with substitute data you define, then sends that output to downstream modules. Use it only when the substitute is semantically valid for every later mapping and action, or when it deliberately marks the record for review. A dummy value that resembles real data can trigger unwanted actions or contaminate later records; make the fallback distinguishable and route it to an appropriate review path. See Make’s Resume error handler guide.
Commit: stop but keep supported changes
Commit stops execution and commits changes already made by modules that support transactions. It does not continue the failed bundle through later modules, and remaining modules are not processed. If no module involved supports transactions, Commit simply stops execution. Make marks transaction-supporting modules with an ACID label. Use this when prior transactional updates are intentional and should remain, but the error means later work must halt. Details are in the Commit error handler guide.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsRollback: stop and revert supported changes
Rollback stops the scenario and reverts changes made by modules that support transactions, including examples such as Data Store and MySQL modules. It cannot undo non-transactional actions such as sending a Gmail message or deleting a Dropbox file. Make marks transaction-supporting modules with an ACID label.
Auto-commit changes what can be undone. When Auto-commit is enabled, earlier module changes are committed and cannot be rolled back; the module that errors may still revert its own transactional changes. When Auto-commit is disabled, supported changes made during that bundle across transactional modules can be reverted. Check the setting before relying on Rollback. Make explains these limits in its Rollback error handler guide.
Rank #4
Configure routes and incomplete executions carefully
An error-handling route attaches to the module that fails. It can include ordinary modules, such as a Slack notification, and does not have to end with one of the five named handlers. If a module on the error-handling route itself fails, the run ends with an error. Make says activating an error handler does not consume operations. See the error-handling overview.
Store incomplete executions preserves failed state for inspection and continuation. Make says executions are not stored if the first module fails, unless Retry is attached to that module, or if storage is full. If storage fills, the Enable data loss setting determines whether Make disables scheduling or continues while discarding an execution it cannot store.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Process data in order prevents concurrent runs and preserves trigger order. With incomplete executions enabled, a later run may wait until an earlier incomplete execution is resolved. This is especially relevant to instant or webhook triggers and stateful workflows.
Make’s overview describes a default threshold of three consecutive errors before a scenario is disabled, with exceptions including instant-trigger scenarios and certain error types. Check the current scenario settings and interface before relying on that threshold; Make’s documentation does not specify a publication date or software version for these pages.
Quick Recap
A practical decision checklist
- Identify what failed: determine whether the cause is likely temporary, invalid input, or a downstream dependency.
- Decide whether the bundle must be preserved: if it must not be lost, avoid Skip; consider Retry or a valid Resume fallback.
- Inspect downstream consequences: confirm any Resume substitute cannot create misleading data or trigger unsafe actions.
- Inspect writes and side effects: identify which modules are ACID/transaction-supporting and which actions cannot be undone.
- Check scenario settings: verify Store incomplete executions, Enable data loss, Process data in order, and Auto-commit as relevant.
- Test the failure path: confirm the failed bundle, other bundles, run status, and any stored or reverted changes match the intended behavior before relying on the route.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
