AWS just closed an 8-year gap with Azure by launching Lambda Durable Functions at re:Invent 2025. The new feature enables developers to build stateful, multi-step workflows directly in Lambda code without Step Functions YAML—supporting executions up to 1 year with automatic checkpointing and zero idle costs. For serverless developers tired of context-switching between business logic and orchestration configs, this is the code-first solution they’ve been waiting for since Azure launched its version in 2017.
AWS Plays Catch-Up to Azure’s 2017 Innovation
Let’s be clear: Azure Durable Functions launched in 2017, giving .NET and JavaScript developers code-first serverless orchestration nearly a decade ago. AWS developers have been stuck with Step Functions—a powerful but YAML-heavy approach that separates workflow logic from business code. The community asked for better. AWS finally delivered, but it took 8 years of watching Azure developers write workflow logic in the same language as their application code.
This isn’t just feature parity. It’s AWS admitting that Step Functions, while excellent for visual orchestration, wasn’t the right tool for every job. Developers wanted workflows in code, not configuration files. They wanted to avoid context-switching between Python/Node.js and JSON state machine definitions. Lambda Durable Functions is AWS’s answer.
What Lambda Durable Functions Actually Do
Lambda Durable Functions introduce three core primitives to the Lambda programming model: steps, waits, and callbacks. Wrap your event handler with the durable execution decorator, and you get automatic checkpointing, failure recovery, and the ability to pause execution for up to a year without paying for idle compute.
The technical innovation is checkpoint-and-replay. When your function hits a checkpoint (via context.step), the system persists progress. If execution fails, replay starts from the beginning but skips completed checkpoints—avoiding redundant work and side effects. Version pinning ensures deterministic behavior: the original function version always handles replay, regardless of code updates between checkpoints.
Here’s the paradigm shift: await context.wait(seconds=300) costs you nothing during those 5 minutes. Step Functions charges per state transition. Durable Functions charges only for active execution time plus checkpoint storage. For workflows with long waits—approval processes, scheduled tasks, human-in-the-loop operations—this cost model is significantly cheaper.
The Step Functions Problem Nobody Talks About
Step Functions require YAML (or JSON) definitions separate from your business logic. You write Python to process an order, then switch to JSON to define the workflow orchestrating that function. For complex, code-heavy workflows, this is cognitive overhead developers don’t want.
The community’s reaction to Durable Functions? “Considerably simpler, less magical, and cheaper than the equivalent Step Function-style implementation would be.” That word—”magical”—is telling. Step Functions abstract orchestration into a visual interface and state machine definitions, which works beautifully when you need to coordinate AWS services (Lambda + S3 + DynamoDB). But for application-level orchestration where workflow logic is business logic, developers prefer code.
Lambda Durable Functions eliminate that separation. Your workflow is code. Your retries are code. Your compensation logic for saga patterns is code. Everything lives in the same file, the same language, the same mental model.
When Durable Functions Win (And When They Don’t)
Use Lambda Durable Functions when you’re building code-heavy workflows with complex business logic, need cost optimization for wait periods, or want to stay in a single language (Python or Node.js). The programming model is familiar—regular Lambda functions enhanced with durable primitives. Developer velocity improves: AWS’s Serverlesspresso demo took 6 hours to build with AI assistance.
Stick with Step Functions when you need visual workflow design, cross-service AWS orchestration, or complex branching easier to represent graphically. Step Functions excel at coordinating multiple AWS services and providing non-developers visibility into workflow states. The tooling is mature, regional availability is broad, and for teams that think in flowcharts, YAML state machines make sense.
The reality: Durable Functions aren’t replacing Step Functions. They’re complementing them. AWS is giving developers choice—code-first for application logic, config-first for service orchestration. Pick the right tool for your use case.
Current Limitations Worth Knowing
Lambda Durable Functions launched in US East (Ohio) only, with support for Python 3.13/3.14 and Node.js 22/24. That’s narrow compared to Step Functions’ global availability and broader language support. Azure Durable Functions supports .NET, Python, JavaScript, PowerShell, and Java—and has 8 years of production hardening.
The pricing model includes charges for durable operations (starting executions, completing steps, creating waits) and data retention (1-90 days configurable). Optimization matters: if you don’t return data from a step, Lambda won’t save it, and you won’t pay for storage. For long-running workflows caching data for months, retention costs add up.
Infrastructure as Code support exists (SAM, CloudFormation, CDK, Terraform), but the ecosystem is young. Expect rough edges as the community builds patterns and best practices.
Code-First Orchestration Wins
AWS listened. Developers asked for workflow orchestration without leaving their code editor, and Lambda Durable Functions deliver. Step Functions remain powerful for visual orchestration and cross-service coordination, but for code-heavy workflows with extended waits, Durable Functions offer a simpler, cheaper path.
Is AWS 8 years late? Yes. Does that diminish the value for AWS developers who’ve been stuck with Step Functions? No. Innovation timing matters less than solving real problems. Lambda Durable Functions solve the “I don’t want to write YAML for my business logic” problem. That’s a win.
