If you have ever stitched together a multi-step workflow out of Step Functions state machines, a couple of SQS queues, and a DynamoDB table you swore was “just temporary,” you already know the pain. AWS Lambda Durable Functions exist to make that pain go away. They let you write long-running, multi-step, fault-tolerant logic as plain sequential code in Python or TypeScript, while the platform quietly handles checkpointing, retries, and recovery underneath you. No state machine JSON. No hand-rolled resume logic. Just code that survives a crash.
What AWS Lambda Durable Functions actually do
Announced at re:Invent 2025 and now generally available across most regions in 2026, durable functions extend the normal Lambda programming model with a few new primitives: steps and waits. You divide your handler into steps, each step checkpoints its result before the next one runs, and if the function dies halfway through, it resumes from the last good checkpoint instead of starting over. Python and TypeScript are GA; a Java durable execution SDK landed in developer preview in early 2026.
The mental model is simple. A step is a unit of work whose output gets persisted. A wait is a pause that costs you nothing in compute on on-demand functions, so you can sit idle for minutes, hours, or longer while you wait on a human approval or an external callback. The SDK records each checkpoint with the operation type, inputs, and result, then persists it before moving on. Replay a function and it skips the steps it already completed.
One constraint worth tattooing on your wrist: the maximum checkpoint size is 256 KB. If a step produces something bigger, use a custom serializer to offload the payload to S3 or DynamoDB and checkpoint a pointer instead. Don’t try to smuggle a 10 MB blob through a checkpoint and act surprised when it complains.
Replacing brittle glue with checkpointed steps
Here is the part that matters. Most “orchestration” in the wild is not orchestration. It is a Lambda that calls another Lambda, catches an exception, writes a status flag somewhere, and hopes a cron job notices when it gets stuck. That cron job you are still babysitting at midnight is not a workflow engine. It is a liability with a schedule.
Durable functions let you express the same flow as readable, imperative code where each external call is its own checkpointed step:
from aws_lambda_durable import durable, stepdurabledef process_order(ctx, event): # Each step is checkpointed; on retry, completed steps are skipped. payment = step(ctx, "charge_payment", charge_card, event["order_id"], event["amount"]) inventory = step(ctx, "reserve_inventory", reserve_items, event["order_id"], event["items"]) # Pause with zero compute cost until the warehouse callback arrives. shipment = ctx.wait_for_signal("shipment_confirmed", timeout=86400) receipt = step(ctx, "send_receipt", email_receipt, event["customer_email"], payment["txn_id"]) return {"status": "complete", "txn": payment["txn_id"], "shipment": shipment["tracking"]}def charge_payment(ctx, order_id, amount): # Real call to your payment provider. If this throws, the SDK # retries the step with backoff and only this step replays. return payments.charge(order_id, amount)
Notice what is missing. There is no status table you manage by hand, no JSON state machine to keep in sync with the code, no resume-from-where-we-died bookkeeping. If reserve_inventory fails, the platform retries that step with backoff while charge_payment stays put because its checkpoint already exists. That is the whole pitch: idempotency and recovery you get for free instead of writing it badly five times.
When durable functions, when Step Functions
This is not a “delete Step Functions” memo. Step Functions still shines when you want a visual, declarative state machine that non-engineers can read, deep service integrations without writing glue code, or a workflow defined entirely in infrastructure rather than application code. Reach for durable functions when the logic is genuinely code, when branching and loops are easier to express in Python than in Amazon States Language, and when you want everything to live in one deployable artifact with normal testing and version control. A lot of teams will run both, and that is fine.
Event-driven patterns that pair well
Durable functions do not replace your event backbone. They sit inside it. The strongest serverless architectures in 2026 still lean on EventBridge for routing and SQS for buffering, and durable functions become the reliable consumers that process those events without losing their place.
A common shape: an EventBridge rule matches a domain event and targets a durable function that runs the multi-step saga. SQS sits in front of spiky producers so you absorb bursts and control concurrency. One quality-of-life win from Q1 2026 is that the maximum payload size jumped from 256 KB to 1 MB for asynchronous Lambda invocations, SQS, and EventBridge, so you can ship context-rich events without the usual “store it in S3 and pass a pointer” dance.
{ "Rules": [{ "Name": "order-placed-to-durable-saga", "EventPattern": { "source": ["com.acme.orders"], "detail-type": ["OrderPlaced"] }, "Targets": [{ "Id": "order-saga", "Arn": "arn:aws:lambda:us-east-1:111122223333:function:process_order", "RetryPolicy": { "MaximumRetryAttempts": 3 }, "DeadLetterConfig": { "Arn": "arn:aws:sqs:us-east-1:111122223333:order-saga-dlq" } }] }]}
Keep a dead-letter queue on every target. Events that can’t be processed should land somewhere visible, not vanish into the void where you discover them three weeks later during an incident review.
Aurora Serverless v2 for the stateful bits
When a step needs a real relational database, Aurora Serverless v2 scales capacity with load and trims it back when traffic drops, which keeps the “serverless” promise intact for the data layer too. Pair it with the RDS Data API or RDS Proxy so a sudden burst of durable functions doesn’t exhaust your connection pool and turn a good day into a pager-storm.
Plugging in AI dev tooling
Writing this stuff got noticeably less tedious. AWS now ships MCP (Model Context Protocol) servers that pull serverless expertise directly into your coding assistant, so the model answering your questions has current, accurate context about Lambda, EventBridge, and durable execution instead of half-remembered blog posts. Anthropic Claude plugins and Kiro Powers go further, offering contextual guidance for architecture, implementation, and deployment as you work, grounded in real AWS patterns.
The practical workflow looks like this: connect the AWS serverless MCP server, ask your assistant to scaffold a durable function with checkpointed steps and a matching EventBridge rule, and let it lean on the Serverless Patterns Collection on Serverless Land, where you can download ready-made pattern .zip files for EventBridge, SQS, Step Functions, and durable execution. You still review every line, because that is your job, but you start from a working pattern instead of a blank file and a vague memory of last quarter’s docs.
Where to start
Pick one brittle workflow you already dread. The order pipeline, the nightly reconciliation job, the multi-stage data import that fails 4 percent of the time and nobody knows why. Rewrite it as a durable function with a step per external call, wire it behind an EventBridge rule with a DLQ, and put Aurora Serverless v2 underneath if it needs a database. Then go enjoy a midnight that does not involve patching a server.
At Enkompass (enkompass.net), this is our home turf. We design and ship event-driven serverless systems that checkpoint reliably, scale to zero when nobody’s knocking, and recover from failures on their own instead of paging a human. If you’d rather have seasoned cloud people handle it instead of learning the hard way at 2 AM, let’s talk. Reach out through our contact page or call us directly at +1-828-436-5667 — we’ll help you turn this from a someday-project into a done-deal.