Durable Execution SDK for .NET — Preview Now Available 🎉

[GarrettBeatty]

Durable Execution SDK for .NET — Preview Now Available 🎉

The AWS Lambda .NET team is excited to announce the preview of the AWS Lambda Durable Execution SDK for .NET (Amazon.Lambda.DurableExecution).

Durable Execution lets you build resilient, long-running Lambda functions that automatically checkpoint their progress and resume after failures. Workflows can run for up to one year, and you're only charged for active compute time — not for the time spent waiting.

Why Durable Execution?

Today, orchestrating multi-step workflows in Lambda often means stitching together Step Functions state machines, SQS queues, or DynamoDB-backed state, and writing your own logic to track progress and recover from failures. Durable Execution lets you express that same workflow as ordinary C# code — await your steps, your waits, and your callbacks — while the SDK handles checkpointing, retries, and replay-safe resumption for you.

Key features

• Automatic checkpointing — progress is saved after each step; failures resume from the last checkpoint.
• Cost-effective waits — suspend execution for minutes, hours, or days without compute charges.
• Configurable retries — built-in retry strategies with exponential backoff and jitter.
• Replay safety — functions deterministically resume from checkpoints after interruptions.
• Type safety — full generic type support for step results.
• AOT-friendly — pluggable ILambdaSerializer for trimmed / Native AOT functions.

For example, a multi-step order workflow with a built-in wait becomes:

private async Task<OrderResult> Workflow(Order order, IDurableContext ctx)
{
    var reservation = await ctx.StepAsync(
        async (_, ct) => await InventoryService.ReserveAsync(order.Items, ct),
        name: "reserve-inventory");

    var payment = await ctx.StepAsync(
        async (_, ct) => await PaymentService.ChargeAsync(order.PaymentMethod, order.Total, ct),
        name: "process-payment");

    // Suspend for 2 hours with no compute charges, then resume.
    await ctx.WaitAsync(TimeSpan.FromHours(2), name: "warehouse-processing");

    var shipment = await ctx.StepAsync(
        async (_, ct) => await ShippingService.ShipAsync(reservation, order.Address, ct),
        name: "confirm-shipment");

    return new OrderResult(order.Id, shipment.TrackingNumber);
}

---

The first preview is available on NuGet:

📦 Amazon.Lambda.DurableExecution 0.0.1-preview

dotnet add package Amazon.Lambda.DurableExecution --version 0.0.1-preview

Preview status. Amazon.Lambda.DurableExecution is in active development (0.x). Public APIs may change before 1.0.

Deployment (preview). Currently, durable functions must be deployed as a container image. This is a temporary restrictions till the .NET managed runtimes are added to the durable function allow list. Functions must also be written using the executable programming model so that you can include the latest version of the Amazon.Lambda.RuntimeSupport package. The example below builds on the public.ecr.aws/lambda/dotnet:10 base image.

Deploying a durable function (container image)

The end-to-end integration tests build, deploy, and invoke durable functions exactly this way. See DurableFunctionDeployment.cs for the full lifecycle (IAM role → ECR repo → image build/push → CreateFunction → invoke), and the TestFunctions/ folder for runnable example functions (each paired with a test).

1. Project file — build an executable named bootstrap:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <OutputType>Exe</OutputType>
    <AssemblyName>bootstrap</AssemblyName>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Amazon.Lambda.DurableExecution" Version="0.0.1-preview" />
    <PackageReference Include="Amazon.Lambda.RuntimeSupport" Version="*" />
    <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="*" />
  </ItemGroup>
</Project>

2. Dockerfile — base on the .NET 10 managed base image and run bootstrap:

FROM public.ecr.aws/lambda/dotnet:10

COPY bin/publish/ ${LAMBDA_TASK_ROOT}

ENTRYPOINT ["/var/task/bootstrap"]

3. Publish, build, and push the image:

# Publish a framework-dependent Linux build into bin/publish/
# (--self-contained false: the dotnet:10 base image supplies the runtime)
dotnet publish -c Release -r linux-x64 --self-contained false -o bin/publish

# Build the container image
docker build --platform linux/amd64 --provenance=false -t <account>.dkr.ecr.<region>.amazonaws.com/my-durable-fn:latest .

# Authenticate to ECR and push
aws ecr get-login-password --region <region> \
  | docker login --username AWS --password-stdin <account>.dkr.ecr.<region>.amazonaws.com
docker push <account>.dkr.ecr.<region>.amazonaws.com/my-durable-fn:latest

4. Create the function with PackageType = Image and a DurableConfig. The execution role needs both the basic execution policy and the durable execution policy:

• arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
• arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy

await lambdaClient.CreateFunctionAsync(new CreateFunctionRequest
{
    FunctionName = "my-durable-fn",
    PackageType  = PackageType.Image,
    Role         = roleArn,
    Code         = new FunctionCode { ImageUri = imageUri },
    Timeout      = 30,
    MemorySize   = 256,
    DurableConfig = new DurableConfig { ExecutionTimeout = 60 }
});

5. Invoke it with a DurableExecutionName, then track it via GetDurableExecution / GetDurableExecutionHistory:

await lambdaClient.InvokeAsync(new InvokeRequest
{
    FunctionName          = "my-durable-fn",
    Qualifier             = "$LATEST",
    Payload               = payload,
    DurableExecutionName  = $"order-{Guid.NewGuid():N}"
});

Core operations

Your handler delegates to DurableFunction.WrapAsync, which gives your workflow an IDurableContext — your interface to durable operations:

• Steps — execute code with automatic checkpointing, retry strategies, and at-least/at-most-once semantics.
• Wait — pause execution without compute charges.
• Wait For Condition — poll until a condition is met, suspending between polls.
• Callbacks — wait for external systems (approvals, webhooks) to respond.
• Child Contexts — group related operations into isolated, checkpointed units.

📖 Learn more in the Durable Execution SDK README, which includes a complete getting-started walkthrough and a full Main + handler example.

Related SDKs

Durable Execution is available across multiple languages:

• aws-durable-execution-sdk-java — Java SDK
• aws-durable-execution-sdk-js — JavaScript / TypeScript SDK
• aws-durable-execution-sdk-python — Python SDK

---

What's still to come 🚧

This is an early preview and we're actively building. On the roadmap:

• ParallelAsync — fan out and run multiple durable branches concurrently.
• MapAsync — apply a durable operation across a collection of items.
• Annotations source generator support — author durable functions with [DurableExecution]-style attributes.
• Local testing SDK — run and step through durable workflows locally.
• Large payload support — handle step inputs/outputs beyond the inline checkpoint size limits.
• Project blueprint — a dotnet new template to scaffold a durable function.
• Managed runtime support — run class-library handlers on the managed runtime (no custom bootstrap / container image required).

---

We want your feedback 🙏

We cannot overstate how critical your feedback is during preview. Please try it out and let us know what works, what doesn't, and what you'd like to see before 1.0 — comment on this issue!

[ParidelPooya]

🎉🎉🎉

[Lanayx]

Does it work with F#?

[normj]

@Lanayx There is nothing C# specific about the Durable function support and F# should have no problems. Will love to hear any feedback if you find issues. Here is my conversation of one of our C# test functions in to F#

open System
open System.Threading
open System.Threading.Tasks
open Amazon.Lambda.Core
open Amazon.Lambda.DurableExecution
open Amazon.Lambda.RuntimeSupport
open Amazon.Lambda.Serialization.SystemTextJson

type TestEvent() =
    member val OrderId : string = null with get, set

type TestResult() =
    member val Status : string = null with get, set
    member val Data : string = null with get, set

type Function() =

    member _.Handler(
        input: DurableExecutionInvocationInput,
        context: ILambdaContext
    ) : Task<DurableExecutionInvocationOutput> =
        DurableFunction.WrapAsync<TestEvent, TestResult>(
            Func<TestEvent, IDurableContext, Task<TestResult>>(fun input context ->
                Function.Workflow(input, context)),
            input,
            context)

    static member private Workflow(
        input: TestEvent,
        context: IDurableContext
    ) : Task<TestResult> =
        task {
            let! step1 =
                context.StepAsync<string>(
                    (fun (_: IStepContext) (_: CancellationToken) ->
                        task {
                            do! Task.CompletedTask
                            return $"validated-{input.OrderId}"
                        }),
                    name = "validate"
                )

            do!
                context.WaitAsync(
                    TimeSpan.FromSeconds(3.0),
                    name = "short_wait"
                )

            let! step2 =
                context.StepAsync<string>(
                    (fun (_: IStepContext) (_: CancellationToken) ->
                        task {
                            do! Task.CompletedTask
                            return $"processed-{step1}"
                        }),
                    name = "process"
                )

            return
                TestResult(
                    Status = "completed",
                    Data = step2
                )
        }

    static member Main(args: string[]) : Task =
        task {
            let handler = Function()
            let serializer = DefaultLambdaJsonSerializer()

            let handlerFunc =
                Func<DurableExecutionInvocationInput, ILambdaContext, Task<DurableExecutionInvocationOutput>>(
                    fun input context -> handler.Handler(input, context)
                )

            use handlerWrapper =
                HandlerWrapper.GetHandlerWrapper<DurableExecutionInvocationInput, DurableExecutionInvocationOutput>(
                    handlerFunc,
                    serializer
                )

            use bootstrap = new LambdaBootstrap(handlerWrapper)

            do! bootstrap.RunAsync()
        }

[<EntryPoint>]
let main args =
    (Function.Main(args)).GetAwaiter().GetResult()
    0