Flowpaja logo Flowpaja
Guide · Make.com · Errors

Make incomplete executions: how to store, retry and resolve failed runs

Make incomplete executions explained: turn on storage, which errors Make retries automatically, the backoff schedule, statuses and how to resolve or retry by hand.

Updated 14 Oct 2026 · ~12 min read

Disclosure: this guide has one affiliate link to Make, marked "affiliate link", and mentions our Fiverr fix service. Error messages, settings and limits come from Make Help Center / app docs checked on 14 October 2026; anything we could not confirm is flagged for review before publishing. We did not reproduce these in a live Make scenario for this guide. Prices, where mentioned, are as seen from the US.

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.

What an incomplete execution is

When a module fails and incomplete executions are enabled, Make stores the unfinished run under the scenario's Incomplete executions tab instead of only failing the History entry. Make's Help Center describes this as a safety feature so you can finish the work or delete it without losing the failed bundle.

Incomplete executions from all scenarios share your organization's incomplete-execution storage allowance (Make's pricing FAQ lists incomplete executions store as part of usage allowance). If that store is full, Make's docs say you get an error message, and the Discard data if storage is full / enable-data-loss setting decides whether the scenario stays on while discarding the failed run.

Turn storage on

  1. Open the scenario in the Scenario Builder.
  2. Open Scenario settings (gear on the toolbar).
  3. 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:

  • RateLimitError
  • ConnectionError
  • ModuleTimeoutError
  • 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.

CauseAutomatic retry?Where Make starts again
RateLimitError, ConnectionError, ModuleTimeoutErrorYes (backoff schedule above)The module that errored
Retry handler with automatic completion YesYes (handler attempts/delay)The module that errored
DataError, BundleValidationError, most other typesNo by defaultFix 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

  1. Activate the scenario (scheduling toggle on). Make only retries when the scenario is active.
  2. Select one or more rows in Incomplete executions.
  3. 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

  1. Open Details (or History → failed run → Resolve).
  2. Open the warning on the failing module, fix the setting or mapping, Save.
  3. 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)

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.

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.

Log failed writes before you retry them

Free template: a request ledger marks each Google Sheets append pending, so a failed write is checked before anyone retries it.

Get the free reconcile template Fix my scenario on Fiverr

Stuck incomplete executions? Send the blueprint and the failed bundle: Make scenario fix on Fiverr (async, from $20 as seen from the US).