Short answer: Incomplete executions are Make's stored unfinished runs. They are off by default. Turn on Store incomplete executions in Scenario settings, then retry temporary failures automatically (or with the Retry handler, formerly Break) and fix other failures by hand in the Incomplete executions tab.
Everything here works on Make's Free plan.
Turn storage on
- Open the scenario in the Scenario Builder.
- Open Scenario settings (gear on the toolbar).
- Set Store incomplete executions to Yes, then Save.
Make's incomplete-executions article states they are disabled by default. The Retry error handler also needs this setting on before it can store a failed bundle for later completion.
What Make retries automatically
With storage enabled, Make checks why each incomplete execution was created. According to Automatic retry of incomplete executions, Make automatically retries incomplete executions caused by:
RateLimitErrorConnectionErrorModuleTimeoutError- Incomplete executions created with the Retry error handler when automatic run completion is enabled
Retries use an exponential backoff schedule. For those three temporary error types Make documents this sequence (times after the original run): 1 minute, then 10 minutes (11 total), 10 minutes (21), 30 minutes (51), 30 minutes (1h21), 30 minutes (1h51), 3 hours (4h51), 3 hours (7h51).
For Retry-handler incomplete executions with automatic completion, Make's default is up to 3 attempts with a 15-minute delay (you can change those in the handler). Other error types usually need a blueprint or mapping change and manual resolve.
| Cause | Automatic retry? | Where Make starts again |
|---|---|---|
RateLimitError, ConnectionError, ModuleTimeoutError
|
Yes (backoff schedule above) | The module that errored |
| Retry handler with automatic completion Yes | Yes (handler attempts/delay) | The module that errored |
DataError, BundleValidationError, most other types |
No by default | Fix mapping/settings, then Resolve / Run once |
Per scenario, Make limits automatic retries to 3 incomplete executions in parallel, in batches, and a retry does not start while the original scenario is already running. That limit is per scenario so mass retries do not recreate rate limits.
When Make does not create an incomplete execution
From Errors that don't create incomplete executions:
- The error is on the first module (unless you attach a Retry handler there, which can still store it).
- Incomplete-execution storage is full and data loss is enabled (failed run discarded) or disabled (scenario scheduling disabled).
- The run lasts longer than the scenario execution time limit (Make's pricing table: 40 minutes paid / 5 minutes Free, checked against pricing; see also timeouts and limits).
- The error happens in initialization or rollback phases, outside the operation phase.
Statuses in the Incomplete executions tab
Open the scenario, switch from Diagram to Incomplete executions. Make documents these statuses:
- Unresolved: not scheduled to retry; retry or resolve manually.
- Pending: scheduled to retry; check Scheduled in.
- In progress: Make is retrying it now.
- Resolved: finished successfully; Make deletes resolved incomplete executions automatically after 30 days.
Each row also shows an incomplete execution ID (usable with the Make app / API), created time, size, attempts, and a Details link into the Scenario Builder.
Retry or resolve by hand
Retry selected
- Activate the scenario (scheduling toggle on). Make only retries when the scenario is active.
- Select one or more rows in Incomplete executions.
- Click Retry selected. Status moves toward Scheduled in / In progress, then Resolved or Unresolved.
A retry starts at the failing module with the same configuration as when it failed. That fits temporary outages, not bad mappings.
Resolve manually
- Open Details (or History → failed run → Resolve).
- Open the warning on the failing module, fix the setting or mapping, Save.
- Click Run once. Success marks the incomplete execution Resolved. Failure on the same module leaves it unresolved; failure later creates a new incomplete execution from the new module.
Delete rows you do not need with Delete selected.
Process data in order
Scenario settings also include Process data in order. When enabled, Make finishes each run before the next starts, and new runs wait until incomplete executions are resolved. Make notes this also applies to webhooks (otherwise webhooks can run in parallel). Use it when order matters more than throughput.
Pair with Skip and Retry handlers
- Skip (formerly Ignore): drop the bad bundle and keep going; no incomplete execution for that bundle.
- Retry (formerly Break): park the bundle as an incomplete execution (storage must be on); optional automatic completion.
See Skip vs Retry in the broader error handling overview.
Sources checked (14 October 2026)
- Incomplete executions
- Automatic retry of incomplete executions
- Manage incomplete executions
- Errors that don't create incomplete executions
- Scenario settings
- Retry error handler
- Make pricing (execution time and usage allowance)
Google autocomplete (US, 14 Oct 2026) returned "make com incomplete executions" for the seed "make.com incomplete executions". Search volume in content_gaps.csv is marked unverified.
Stuck on this error? I'll fix your Make scenario from the blueprint. No login, no calls. From $20 on Fiverr
Get it fixed on Fiverr (opens Fiverr in a new tab)
Don't have a Make account yet? You can build and test this scenario on Make's free plan.
Create a free Make account (opens Make in a new tab)
Affiliate link: Flowpaja may earn a commission at no extra cost to you.
FAQ
Are incomplete executions on by default in Make?
No. Make's Help Center says they are disabled by default. Enable Store incomplete executions in Scenario settings.
Which errors does Make retry automatically?
With storage on, Make automatically retries incomplete executions from RateLimitError, ConnectionError and ModuleTimeoutError, plus Retry-handler executions with automatic completion enabled.
How long does Make keep resolved incomplete executions?
Make deletes resolved incomplete executions automatically after 30 days.
Why is there no incomplete execution for my error?
Errors on the first module (without a Retry handler), runs over the execution time limit, initialization or rollback errors, and full storage can all prevent one being stored.
Can I retry an incomplete execution while the scenario is off?
No. Make's docs say you can retry incomplete executions only when the scenario is active.
Top comments (0)