Picture this: your payment provider starts returning errors on a Tuesday afternoon. Dozens of order workflows built on Lambda durable functions are mid-flight. Until recently you had two bad choices: let them burn through their retries, or stop them for good and clean up by hand once the provider is back. Neither fits a twenty-minute wobble.

Since November 17, 2026, there is a third option: you can pause a durable execution and resume it later from its last checkpoint. I wrote a detailed walkthrough in How to pause durable functions in AWS Lambda, and here is the condensed picture of what matters.

The pause is per execution, not per function

This is the part that surprised me most. PauseDurableExecution acts on exactly one execution. There is no switch that freezes a whole function. If 300 orders are running, you need 300 pause calls, ideally from a script that pages through ListDurableExecutionsByFunction, limits concurrency to avoid throttling and passes an idempotent ClientToken.

Even more important: pausing does not stop new executions from starting. Every fresh order with a new name runs straight into the broken dependency. So an emergency brake always needs two levers: cut the intake (for example, disable the SQS event source mapping or stop the callers) and pause what is already running.

PAUSING is not PAUSED

The status model has a subtle step in it. If an execution is idle, sitting in a context.wait(), a callback or a retry delay, it moves directly to PAUSED. If an invocation is currently running, it lands in PAUSING first and keeps working until the next checkpoint. Only then does Lambda end the invocation.

A few consequences I would keep in mind:

  • A long step can delay the pause up to the function timeout.
  • An execution that finishes before its next checkpoint simply completes and is never paused.
  • Right after the API call, the status may still show RUNNING, so check again.
  • On resume, the execution continues on the same function version. A deployment during the pause does not swap code underneath it.

Things that keep moving while you wait

A pause only stops Lambda from invoking your function. Waits keep counting down, callbacks can still arrive or time out, and child executions started through chained invokes are not paused with their parent. Your code sees all of that in the first invocation after resume.

By default the execution timeout is paused too, and the deadline is extended by the paused time, capped at 366 days after the start. Costs do not disappear either: there are no invocation charges while paused, but the stored execution data is still billed and the execution still counts against your quota of open durable executions.

Here is the core of a bulk pause in TypeScript, simplified:

const pages = paginateListDurableExecutionsByFunction( { client, pageSize: 100 }, { FunctionName: "bookshop-orders", Statuses: ["RUNNING"] }, ); for await (const page of pages) { for (const e of page.DurableExecutions ?? []) { await client.send(new PauseDurableExecutionCommand({ DurableExecutionArn: e.DurableExecutionArn, Reason: "Payment provider outage", })); } } 

The full version in the article adds a concurrency pool, idempotency tokens, handling for ResourceConflictException, a dry-run mode and a small CLI with pause, resume and purge commands.

Deleting finished executions early

The same release added DeleteDurableExecution. It removes a finished execution (SUCCEEDED, FAILED, STOPPED or TIMED_OUT) together with its history, checkpoints, input and output. That is useful for GDPR erasure requests or for cleaning up after a bug. Two caveats: logs, metrics, CloudTrail records and data your steps wrote elsewhere stay where they are, and deleting early does not lower storage charges. If you want to save money, shorten the retention period instead.

My recommendation: do not write the brake during an incident. Put it in your runbook now and practice it once in a test environment.

What the full article covers

  • The complete status model, including stop and the asynchronous DELETING state
  • A decision guide for pause vs. stop vs. disabling the trigger
  • Step-by-step AWS CLI commands to list, pause, check and resume executions
  • A ready-to-run TypeScript emergency brake with tests and an IAM policy split between on-call and deletion roles
  • Common mistakes such as expiring callbacks, forgotten child executions and outdated SDK versions

Read it here: How to pause durable functions in AWS Lambda

📖 This is the condensed version. The full article on sascha-ms.de goes deeper – with all code samples, diagrams and a short knowledge check.

👉 Next step: Curious what your own Lambda functions cost? Try my Lambda cost calculator – it runs right in your browser.

📬 Stay updated: New articles on serverless, AI and leading tech teams via RSS, browser push or the weekly newsletter (in German).

Originally published on sascha-ms.de. More articles on serverless, AI in everyday development and leading tech teams: sascha-ms.de/en