Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallIn Make, an error handler changes what happens to the bundle that failed; it does not necessarily stop the whole scenario. Depending on the handler and scenario settings, Make can discard that bundle, pause it for retry, continue with a substitute value, or stop while preserving or reverting changes. When incomplete-execution storage is enabled, Make can retain eligible failed work while other pending bundles continue processing.
What happens to the failed bundle?
A bundle that encounters an error stops at the failing module rather than continuing along its normal downstream path. The handler determines what Make does next with that bundle.
| Handler | What happens to the failed bundle | Effect on scenario execution |
|---|---|---|
| Skip | The bundle is discarded from the scenario flow. | Subsequent bundles can proceed; Make describes the run as successful despite the error. |
| Retry | The failed bundle and its execution details are retained for another attempt. | The failed bundle is removed from the current flow so other bundles can continue; the stored execution can be retried automatically or manually. |
| Resume | A substitute value is supplied for the failed module. | Processing continues using that value. |
| Commit | Processed changes are saved. | Scenario execution stops. |
| Rollback | Changes are reverted. | Scenario execution stops. |
These are the five handler names used in the Make Help Center’s error-handler quick reference. The overview of error handling provides additional context.
Does Make keep processing other bundles after an error?
It can. When incomplete-execution storage is enabled and earlier modules have output bundles still waiting, Make can treat the failure as a warning, stop the failed bundle at its module, and process the other pending bundles. The errored execution is then stored in the Incomplete Executions tab for review or retry. This pending-bundle behavior is described in Make’s documentation on incomplete executions; it does not mean that the failed bundle itself continues through its regular downstream route.
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 problemsHow Retry and incomplete executions work
Retry is intended for failures that may be temporary or that require intervention. It stores the failed bundle’s error information and execution details, along with the remaining scenario flow. Make can retry the stored execution automatically according to the configured attempts and interval, or it can be handled manually. Make’s example of three additional attempts at 15-minute intervals is an example configuration, not a universal default. See the Retry error handler documentation for details.
To allow Make to store incomplete executions, open the scenario settings and enable Store incomplete executions. The setting is off by default. Stored executions may be retried automatically for supported error types, resolved manually, or deleted. The maximum number retained across an organization’s scenarios and teams depends on its usage allowance.
When Make may not store an incomplete execution
Storage is not guaranteed for every failure. Make documents these exceptions and capacity behaviors in its list of errors that do not create incomplete executions:
- Error on the first module: It normally does not create an incomplete execution. Adding a Retry handler to that module enables storage.
- Storage is full: If Enable data loss is disabled, Make disables the scenario. If it is enabled, scheduled runs continue and an execution that cannot be stored is discarded.
- Initialization or rollback error: Errors in these phases do not create an incomplete scenario run.
- Run-duration limit exceeded: Errors after the scenario exceeds its run-duration limit are also listed as cases that do not create an incomplete execution.
Choosing a handler for the outcome you need
- Use Retry when the failed work should be attempted again or reviewed later.
- Use Skip when the failed bundle should be dropped and processing should move on.
- Use Resume when you can supply a suitable substitute value and continue the flow.
- Use Commit when the scenario should stop but retain changes already processed.
- Use Rollback when the scenario should stop and undo changes already processed.
Before relying on recovery, check that incomplete-execution storage is enabled and that the failure type is eligible for storage. A handler’s effect on the failed bundle and the fate of other pending bundles are related, but they are not the same outcome.
Quick Recap
Rank #3
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.
