By AWS Lambda just broke its own 15-minute execution limit. At re:Invent 2025 (December 2-5), Amazon announced Lambda Durable Functions – workflows that run for up to a year with built-in progress tracking and automatic failure recovery. For 10+ years, Lambda meant “short executions only.” Not anymore. This fundamentally changes what serverless can do.
What Lambda Durable Functions Actually Do
Lambda Durable Functions let you build multi-step workflows that run from seconds to one year. The key innovation is a checkpoint and replay mechanism. Each step in your workflow creates a checkpoint. If a function fails or needs to wait for external data, it suspends execution without costing you compute time. When it resumes, Lambda replays from the beginning but skips completed checkpoints using saved results. Built-in error handling automatically retries failed steps.
The technical details: Available in US East (Ohio), supports Python 3.13/3.14 and Node.js 22/24, uses an open source SDK. Functions can suspend for up to a year while waiting for callbacks. The revolutionary part? You don’t pay for suspension time. That’s a complete inversion of traditional serverless economics.
AWS provides the technical deep dive showing how checkpoint and replay work under the hood. It’s elegant: state persists to DynamoDB, replays skip completed work, and idempotency is built-in.
Step Functions Just Became Redundant
Here’s the elephant in the room: AWS just made Step Functions unnecessary for 80% of workflows. Before Durable Functions, you needed Step Functions to orchestrate multi-step Lambda processes. Now you write sequential code in Python or JavaScript. No state machines. No JSON definitions. Just normal code with @durable_step decorators.
The cost angle matters. Step Functions charge per state transition PLUS Lambda execution time. Durable Functions charge only for Lambda execution. For high-volume workflows, this is massive savings. Add developer productivity: code is faster to write and debug than state machines. InfoQ’s analysis notes the community consensus – this makes Step Functions redundant for most use cases.
Step Functions still win for complex branching logic with dozens of conditional paths, visual representation requirements, and enterprise governance needs. But for payment processing, customer onboarding, data pipelines? Lambda Durable Functions are simpler and cheaper. That’s not marketing spin – that’s architectural reality.
The AI Workflow Timing
The timing isn’t coincidental. AI agents need multi-step reasoning loops: think, act, observe, repeat. These workflows can run for hours or days. Lambda’s old 15-minute limit forced developers to use external orchestration. Durable Functions solve this natively.
Amazon Bedrock AgentCore – announced at the same re:Invent – builds AI agents that work autonomously for days. Lambda Durable Functions provide the execution layer. The checkpoint and replay mechanism matches AI agent decision-making patterns perfectly. One company using AgentCore cut deployment cycles from 4 weeks to 1 week.
This signals a bigger shift. Serverless is evolving from event-driven to workflow-driven. AI workloads are driving the change. AWS is betting that long-running, stateful serverless is the future. They’re probably right.
How It Works in Code
A simple order processing workflow shows the pattern:
from aws_durable_execution_sdk_python import durable_execution, durable_step
@durable_execution
def order_workflow(event, context):
# Step 1: Reserve inventory (checkpoint created)
inventory_id = context.step(reserve_inventory, order_data)
# Step 2: Process payment (automatic retry on failure)
payment_result = context.step(process_payment, order_data)
# Step 3: Wait for payment gateway (suspend, no cost)
context.wait(payment_callback)
# Step 4: Create shipment (checkpoint)
shipment_id = context.step(create_shipment, order_data)
return {"status": "complete", "shipment_id": shipment_id}Each context.step() creates a checkpoint. context.wait() suspends without cost. Automatic retry on failure. Idempotent by design because saved checkpoint results get reused. It’s normal Python code, not state machine JSON. That matters for maintainability.
The AWS Lambda Durable Functions documentation includes more examples for JavaScript and TypeScript. The SDK is open source, which means community contributions and transparency.
What Developers Should Do Now
Three actions:
Evaluate existing Step Functions workflows. Many can migrate to simpler Lambda Durable Functions. You’ll get cost savings and developer productivity gains. Run the numbers on state transition fees versus pure execution costs.
Test for AI agent use cases. If you’re building AI workflows, this is your execution layer. Integrate with Bedrock AgentCore or your own agent framework. The checkpoint and replay model fits AI reasoning loops naturally.
Watch for broader availability. Currently US East (Ohio) only. AWS will expand regions based on demand. If you need this in production today, you know where to deploy.
The decision framework is straightforward. Simple to moderate workflows? Lambda Durable Functions. Complex branching and enterprise governance? Step Functions. Continuous processing without breaks? ECS Fargate. Each workflow step under 15 minutes? Lambda Durable Functions win on cost and simplicity.
The Serverless Evolution
Lambda Durable Functions represent serverless growing up. We’ve moved from “execute this function when an event fires” to “execute this complex workflow over days or weeks.” The economic model shifted from “pay for every millisecond” to “pay only for actual work, not waiting.”
AWS is repositioning its entire serverless stack around AI workloads. Durable Functions, AgentCore, Trainium3 chips – it’s a coordinated strategy. They’re betting that 2026 is the year AI agents go from proof-of-concept to production. The infrastructure needs to support long-running, multi-step, fault-tolerant workflows. That’s what Durable Functions deliver.
For developers, the mental model just simplified. Write sequential code. Let AWS handle checkpointing, replay, and failure recovery. Focus on business logic, not infrastructure orchestration. That’s the promise. Whether it delivers at scale is what we’ll learn in 2026.
