WorkflowForge Performance Benchmarks

This document provides comprehensive performance analysis of WorkflowForge, including both internal performance characteristics and competitive comparisons.

Test System: Windows 11 (25H2), Intel 11th Gen i7-1185G7, .NET 8.0.23
Benchmark Framework: BenchmarkDotNet v0.15.8
Iterations: 50 per benchmark, 5 warmup iterations
Last Updated: January 2026

Table of Contents

1. Internal Performance Benchmarks
2. Competitive Performance Summary
3. Performance Optimization Guide

Internal Performance Benchmarks

These benchmarks measure WorkflowForge’s intrinsic performance characteristics in isolation.

Operation Performance

Single Operation Execution Times (Median, 50 iterations):

Operation Creation Overhead (Median):

Key Insights:

• Operation execution: 11.85-36.0μs median (microsecond scale)
• Operation creation: <2.0μs (negligible overhead)
• Custom operations are the most memory-efficient (296B)
• Median values are more representative than means (due to GC outliers)

Workflow Throughput

Sequential Custom Operations (varying operation count):

ForEach Loop Workflow (10 operations):

• Median: 610.7μs
• Memory: 4.54 KB

High Performance Configuration (10 operations):

• Median: 635.2μs
• Memory: 13.61 KB

Key Insights:

• Throughput remains under 200μs median for up to 50 operations
• Linear memory scaling (1.92KB to 23.95KB for 1-50 operations)
• High-performance config adds minimal overhead

Concurrency Performance

8 Concurrent Workflows (5 operations each):

Speedup: 8x for 8 concurrent workflows (near-perfect scaling)

Scaling by Concurrency Level (5 operations per workflow):

Key Insights:

• Near-perfect linear scaling for concurrent workflows
• Minimal memory overhead per workflow (~8KB)
• Consistent per-workflow execution time regardless of concurrency

Memory Allocation

Minimal Allocation Baseline (varying iteration count):

Key Insight: Minimal allocation workflow maintains constant 2.65KB footprint regardless of scale.

Garbage Collection Characteristics:

• No Gen2 collections in typical scenarios
• Minimal Gen0 collections
• Large object allocations (>85KB) only in stress tests

Configuration Overhead

Configuration Profile Performance:

Key Insight: Configuration profile overhead is negligible (<5μs).

Competitive Performance Summary

WorkflowForge vs. Workflow Core and Elsa Workflows across 12 scenarios with 50 iterations each.

Performance Advantage Overview

Execution Speed:

• 11-540x faster across 12 scenarios
• Operates at microsecond scale (13-497μs) vs. millisecond scale (0.8-94ms)
• State Machine scenarios show highest advantage: 303-540x
• Advantage increases with workload complexity

Memory Efficiency:

• 9-573x less memory allocation
• Kilobytes (3.5-121KB) vs. megabytes (0.04-19MB) for competitors
• No Gen2 GC collections in typical workflows

Visual Comparison

Scaling Performance

Performance advantage increases with workload. See the full competitive analysis for detailed scaling charts.

By Scenario (Median Values)

*I/O-bound scenarios; advantage is in memory efficiency.

Memory Comparison (Selected Scenarios)

Full competitive analysis: competitive-analysis.md

Performance Optimization Guide

1. Choose the Right Operation Type

For Maximum Performance:

• Use custom class-based operations (26.1μs median, 296B allocation)
• Avoid delegate operations when performance is critical (37.8μs median)

// BEST PERFORMANCE
public class ProcessDataOperation : WorkflowOperationBase
{
    protected override async Task<object?> ForgeAsyncCore(
        object? inputData,
        IWorkflowFoundry foundry,
        CancellationToken cancellationToken)
    {
        // Your logic here
        return null;
    }
}

// GOOD PERFORMANCE (but slightly slower)
.AddOperation("ProcessData", async (foundry, ct) => { /* logic */ })

2. Use Appropriate Options

Production defaults:

var foundry = WorkflowForge.CreateFoundry(
    "MyWorkflow",
    options: new WorkflowForgeOptions
    {
        ContinueOnError = false,
        FailFastCompensation = false,
        ThrowOnCompensationError = true
    });

High-throughput batch scenarios:

var foundry = WorkflowForge.CreateFoundry(
    "MyWorkflow",
    options: new WorkflowForgeOptions
    {
        ContinueOnError = true,
        FailFastCompensation = false,
        ThrowOnCompensationError = false
    });

Choose based on behavior requirements rather than micro-optimizations.

3. Optimize Data Passing

Use foundry.Properties for all data (primary pattern):

// Store data
foundry.SetProperty("Key", value);

// Retrieve data
var value = foundry.GetPropertyOrDefault<T>("Key");

Avoid excessive property reads/writes:

// BAD: Multiple redundant reads
for (int i = 0; i < 1000; i++) {
    var config = foundry.GetPropertyOrDefault<Config>("Config");
    // Use config
}

// GOOD: Cache property value
var config = foundry.GetPropertyOrDefault<Config>("Config");
for (int i = 0; i < 1000; i++) {
    // Use cached config
}

4. Leverage Concurrency

Use ForEachWorkflowOperation for parallel execution of independent operations:

// Execute operations concurrently with CPU-based throttling
var operation = ForEachWorkflowOperation.CreateSharedInput(
    new[] { new ProcessItemOperation(), new ValidateOperation(), new AuditOperation() },
    maxConcurrency: Environment.ProcessorCount
);

// Or split input collection among operations
var splitOp = ForEachWorkflowOperation.CreateSplitInput(
    itemOperations,
    maxConcurrency: 4
);

Benchmark result: Near-perfect linear scaling (16x speedup for 16 workflows).

5. Minimize Middleware

Add only necessary middleware:

// Middleware adds overhead, only use what's needed
foundry.AddMiddleware(new TimingMiddleware());       // ~1-2μs overhead
foundry.AddMiddleware(new ValidationMiddleware());   // ~1-5μs overhead

Middleware ordering matters (see operations.md).

6. Reuse Workflows and Foundries

Reuse workflow definitions:

// Build once
var workflow = WorkflowForge.CreateWorkflow("Process")
    .AddOperation(new Step1())
    .AddOperation(new Step2())
    .Build();

// Execute many times
for (int i = 0; i < 1000; i++) {
    await smith.ForgeAsync(workflow, data);
}

Creation overhead is minimal (13μs), but reuse is still best practice.

7. Monitor Memory Allocations

Use minimal allocation patterns:

• Start with 2.65KB baseline
• Expect linear scaling (~500B per operation)
• Monitor for unexpected Gen2 collections

Tools:

• BenchmarkDotNet for allocation tracking
• Performance monitoring extension
• .NET diagnostic tools

8. Use Async/Await Properly

Always use async/await for I/O:

// GOOD
protected override async Task<object?> ForgeAsyncCore(...)
{
    var result = await httpClient.GetAsync(url);
    return result;
}

// BAD (blocks thread)
protected override async Task<object?> ForgeAsyncCore(...)
{
    var result = httpClient.GetAsync(url).Result;  // Deadlock risk
    return result;
}

9. Profile Your Workflows

Use built-in performance monitoring:

foundry.EnablePerformanceMonitoring();

// After execution
var metrics = foundry.GetPerformanceMetrics();
Console.WriteLine($"Total Duration: {metrics.TotalDuration}ms");
Console.WriteLine($"Memory: {metrics.MemoryAllocated}KB");

Benchmark Methodology

Internal Benchmarks

Configuration:

• Framework: BenchmarkDotNet v0.15.8
• Runtime: .NET 8.0.23
• Mode: Median-focused (more stable than mean)
• Iterations: 50 per benchmark
• Warmup: 5 iterations

Scenarios Tested:

1. Operation Performance (OperationPerformanceBenchmark)
2. Workflow Throughput (WorkflowThroughputBenchmark)
3. Concurrency Scaling (ConcurrencyBenchmark)
4. Memory Allocation (MemoryAllocationBenchmark)
5. Configuration Overhead (ConfigurationProfilesBenchmark)

Competitive Benchmarks

Configuration:

• Same as internal benchmarks
• Identical scenarios across all frameworks
• Fair implementations (no artificial handicaps)

Scenarios Tested:

1. Sequential Workflow (1, 5, 10, 25, 50 operations)
2. Data Passing (5, 10, 25 operations)
3. Conditional Branching (5, 10, 25 operations)
4. Loop/ForEach (10, 25, 50 items)
5. Concurrent Execution (1, 4, 8 workflows)
6. Error Handling
7. Creation Overhead
8. Complete Lifecycle (WorkflowCore excluded, see competitive-analysis.md)

Statistical Significance:

• Median values used (more stable than mean)
• Standard deviation < 20% of mean (most scenarios)
• P95 values provided for consistency verification
• 50 iterations ensure statistical confidence

Reproduction

Running Internal Benchmarks

cd src/benchmarks/WorkflowForge.Benchmarks
dotnet run -c Release

Results will be in BenchmarkDotNet.Artifacts/results/.

Running Competitive Benchmarks

cd src/benchmarks/WorkflowForge.Benchmarks.Comparative
dotnet run -c Release

Results will be in BenchmarkDotNet.Artifacts/results/.

Note: Benchmarks may take 30-60 minutes to complete.

Performance Targets

WorkflowForge maintains the following performance targets:

All targets met or exceeded.

Performance History

Version 2.0.0 (Current - January 2026)

• 12 scenarios tested against Workflow Core and Elsa
• 11-540x faster than competitors (State Machine: 303-540x)
• 9-573x less memory allocation
• Near-perfect concurrent scaling
• Microsecond-level operation execution
• Tested with BenchmarkDotNet v0.15.8 on .NET 8.0.23

Version 1.x

• No official benchmarks published
• Internal testing showed strong performance
• Competitive analysis not conducted

Conclusion

WorkflowForge delivers exceptional performance for high-throughput, low-latency workflow orchestration:

• Microsecond-scale execution (13-497μs typical)
• Minimal memory footprint (3.5-121KB across scenarios)
• Near-perfect concurrent scaling (16x speedup for 16 workflows)
• 11-540x faster than competitors (State Machine: 303-540x)
• 9-573x less memory than competitors

12 Benchmark Scenarios Tested:

1. Sequential, Data Passing, Conditional, Loop (26-129x faster)
2. Concurrent Execution (109-264x faster)
3. State Machine (303-540x faster - highest advantage)
4. Parallel Execution (38-380x faster)
5. Error Handling, Creation Overhead, Complete Lifecycle
6. Long Running, Event-Driven (I/O-bound, but 51-423x less memory)

Best suited for:

• High-throughput processing (>1,000 workflows/sec)
• Real-time orchestration (<1ms latency)
• Microservices and API orchestration
• Memory-constrained environments

For detailed competitive analysis and architectural comparisons, see competitive-analysis.md.

Related Documentation

• Internal Benchmarks - Detailed internal benchmark results
• Competitive Analysis - Head-to-head comparisons