How does orchestrator replay work?

Orchestrator functions must be deterministic because the Durable Task Framework replays them from the beginning whenever they resume after waiting for an activity, timer, or external event. During replay, previously completed activity results are returned from the history table without re-executing. This means you must never use non-deterministic operations (random numbers, current time, GUID generation, HTTP calls) directly in orchestrator code — instead, use activity functions for any non-deterministic work. The framework provides deterministic alternatives like currentUtcDateTime for timestamps.

What is the difference between sub-orchestrations and activity functions?

Activity functions are single units of work — they run once, produce a result, and have no orchestration capabilities. Sub-orchestrations are full orchestrator functions called from a parent orchestrator, enabling composition of complex workflows from reusable pieces. Sub-orchestrations can contain their own activity calls, timers, waits for external events, and even nested sub-orchestrations. Use activity functions for individual tasks (send email, process file) and sub-orchestrations for reusable workflow segments (order processing pipeline, multi-step approval chain).

Durable Functions Builder

ServerlessAzure

Build Durable Functions orchestration patterns with activities and sub-orchestrations.

Last verified: May 2026

Durable Functions Configuration

Build Durable Functions orchestration configs with activities, sub-orchestrations, timers, and retry policies.

Required Fields

orchestrationNamefunctionAppNametaskHubNameorchestration.patternorchestration.activities

{
  "orchestrationName": "OrderProcessingOrchestrator",
  "functionAppName": "func-orders-prod",
  "resourceGroup": "rg-serverless",
  "taskHubName": "OrdersTaskHub",
  "durableTaskVersion": "2.x",
  "storageProvider": {
    "type": "AzureStorage",
    "connectionStringName": "AzureWebJobsStorage",
    "partitionCount": 4
  },
  "orchestration": {
    "pattern": "FunctionChaining",
    "activities": [
      {
        "name": "ValidateOrder",
        "type": "Activity",
        "input": "OrderRequest",
        "output": "ValidationResult",
        "retryPolicy": {
          "maxNumberOfAttempts": 3,
          "firstRetryIntervalInSeconds": 5,
          "backoffCoefficient": 2.0,
          "maxRetryIntervalInSeconds": 60
        }
      },
      {
        "name": "ReserveInventory",
        "type": "Activity",
        "input": "OrderDetails",
        "output": "ReservationResult",
        "retryPolicy": {
          "maxNumberOfAttempts": 5,
          "firstRetryIntervalInSeconds": 10,
          "backoffCoefficient": 2.0,
          "maxRetryIntervalInSeconds": 120
        }
      },
      {
        "name": "ProcessPayment",
        "type": "Activity",
        "input": "PaymentRequest",
        "output": "PaymentResult",
        "retryPolicy": {
          "maxNumberOfAttempts": 3,
          "firstRetryIntervalInSeconds": 15,
          "backoffCoefficient": 2.0,
          "maxRetryIntervalInSeconds": 300
        }
      },
      {
        "name": "SendConfirmation",
        "type": "Activity",
        "input": "OrderConfirmation",
        "output": "NotificationResult"
      }
    ],
    "subOrchestrations": [
      {
        "name": "ShippingSubOrchestrator",
        "pattern": "FanOutFanIn",
        "fanOutActivities": ["GetShippingQuotes", "CalculateTax", "ValidateAddress"]
      }
    ],
    "timers": [
      {
        "name": "PaymentTimeout",
        "duration": "PT30M",
        "description": "Cancel order if payment not received within 30 minutes"
      }
    ],
    "externalEvents": [
      {
        "name": "ApprovalEvent",
        "timeout": "PT24H",
        "description": "Wait for manager approval on high-value orders"
      }
    ]
  },
  "hostSettings": {
    "maxConcurrentActivityFunctions": 10,
    "maxConcurrentOrchestratorFunctions": 5,
    "extendedSessionsEnabled": true,
    "extendedSessionIdleTimeoutInSeconds": 30
  }
}

Generated Output

Output will appear here...

See It in Action

Your team is building an order processing workflow: validate payment, reserve inventory, charge card, send confirmation, schedule fulfillment. With Logic Apps, this required visual designer + JSON. With Step Functions, it required ASL. With Durable Functions, you write C# code that reads top-to-bottom: each step is an activity function, error handling is try/catch, retries are configured per-call. The builder generates the boilerplate (orchestrator skeleton, activity stubs, retry policies). Migration from a 200-line Logic App to ~80 lines of C# Durable Functions code with cleaner error handling.

What This Tool Does

Azure Durable Functions is an extension of Azure Functions that lets you write stateful, long-running workflows in code using orchestrator functions. Instead of managing state machines or queues yourself, you define orchestration logic in C#, JavaScript, Python, or Java, and the Durable Task Framework handles state persistence, checkpointing, and replay. The framework supports patterns like function chaining, fan-out/fan-in, async HTTP APIs, monitoring (polling), and human interaction (approval workflows). The Durable Functions Builder helps you configure orchestration patterns with activity functions, sub-orchestrations, timers, and external event handling.

Technical Details

The builder generates Durable Functions orchestrator code templates for common patterns: function chaining (sequential activity calls), fan-out/fan-in (Task.WhenAll over parallel activities), monitor (loop with timer until condition met), human interaction (WaitForExternalEvent with timeout), and saga (compensation logic on failure). Output is C#, JavaScript, or Python orchestrator code with corresponding activity function signatures and host.json configuration.

Common Use Cases

1Building fan-out/fan-in orchestrations that process thousands of items in parallel and aggregate the results
2Creating long-running approval workflows that wait for external events with configurable timeouts
3Defining monitor patterns that poll an external API at configurable intervals until a condition is met
4Configuring orchestration chaining patterns with error handling and compensation logic for saga transactions

Common Questions

How does orchestrator replay work?: Orchestrator functions must be deterministic because the Durable Task Framework replays them from the beginning whenever they resume after waiting for an activity, timer, or external event. During replay, previously completed activity results are returned from the history table without re-executing. This means you must never use non-deterministic operations (random numbers, current time, GUID generation, HTTP calls) directly in orchestrator code — instead, use activity functions for any non-deterministic work. The framework provides deterministic alternatives like currentUtcDateTime for timestamps.
What is the difference between sub-orchestrations and activity functions?: Activity functions are single units of work — they run once, produce a result, and have no orchestration capabilities. Sub-orchestrations are full orchestrator functions called from a parent orchestrator, enabling composition of complex workflows from reusable pieces. Sub-orchestrations can contain their own activity calls, timers, waits for external events, and even nested sub-orchestrations. Use activity functions for individual tasks (send email, process file) and sub-orchestrations for reusable workflow segments (order processing pipeline, multi-step approval chain).

Expert Tips

TIP

ALL non-determinism MUST go in activity functions, never in orchestrator code. The most common bug: calling DateTime.Now or Guid.NewGuid in orchestrator code — works fine on first execution, breaks on replay because the value differs. Use context.CurrentUtcDateTime and context.NewGuid() in orchestrator code.

TIP

Sub-orchestrations are the right abstraction unit for reusable workflow segments. A 'process order' workflow that calls 'validate-payment', 'reserve-inventory', 'send-confirmation' sub-orchestrations is dramatically more maintainable than one giant orchestrator with all logic inline. Each sub-orchestration is independently testable and can be reused across parent workflows.

TIP

Fan-out/fan-in patterns scale beautifully with Durable Functions but watch the 10K-task limit per orchestration in some plans. For massive fan-outs (100K+ tasks), use ContinueAsNew to chunk work across multiple orchestration instances or use Azure Batch instead.

Related Learning Guides

Functions Hosting Plans22 min read

Was this tool helpful?

Disclaimer: This tool runs entirely in your browser. No data is sent to our servers. Always verify outputs before using them in production. AWS, Azure, and GCP are trademarks of their respective owners.