Kestra Orchestration Benchmark Results: Throughput and Latency

Kestra is an orchestration platform: you define a flow, and Kestra orchestrates it. Flows can range from lightweight tasks running in milliseconds to complex scripts in containers that run for tens of minutes.

See Kestra orchestration benchmark results

This benchmark focuses on orchestration performance, including dispatching to the Kestra Worker, rather than workload execution, which varies by use case. To isolate orchestration performance, we use workflows with fast tasks, such as:

• io.kestra.plugin.core.log.Log — logs a single message.
• io.kestra.plugin.core.output.OutputValues — produces a single output (simulating a data-oriented workflow).

Test environment

Benchmarks were run on a Google Cloud n2-standard-4 VM (4 vCPUs, 16 GB RAM) with three setups:

1. Kestra Open Source (OSS) — Postgres 16 backend (4 vCPUs, 16 GB RAM). Database runs remotely to simulate production.
2. Kestra Enterprise Edition (EE) — RabbitMQ and Postgres 16 (4 vCPUs, 16 GB RAM). Both run on separate VMs. Target low-latency and high-throughput use cases.

Benchmark 1 — simple flow

Description Triggered by a Webhook. Contains two tasks:

1. Outputs a variable.
2. Logs that variable.

id: benchmark01
namespace: benchmarks

triggers:
  - id: webhook
    type: io.kestra.plugin.core.trigger.Webhook
    key: benchmark

inputs:
  - id: name
    type: STRING
    defaults: World

tasks:
  - id: concatenate
    type: io.kestra.plugin.core.output.OutputValues
    values:
      message: Hello {{ inputs.name }}
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: "{{ outputs.concatenate.values.message }}"

Results for Kestra OSS (Postgres)

Results for Kestra EE (RabbitMQ + Postgres)

Key takeaways

• At 1000 executions/min (2000 tasks/min), execution latency is approximately 115ms — similar to a single execution time.
• Kestra OSS (Postgres backend) sustains up to 4000 executions/min (8000 tasks/min) with an execution duration of less than 1s, which is what we could realistically target for such a workflow.
• Kestra EE (RabbitMQ + Postgres backend) sustains up to 7000 executions/min (14000 tasks/min); the benchmark harness did not saturate this limit.
• Kestra EE has 55% lower latency and supports significantly higher throughput than Kestra OSS.
• At sustained throughput, p99 latency stays well under 1s.

Benchmark 2 — complex flow

Description Triggered by a Webhook. Contains 5 If tasks with 2 subtasks each (only one executes per run). This creates 10 task runs per execution and stresses the Executor.

id: benchmark02
namespace: benchmarks

inputs:
  - id: condition
    type: BOOL
    defaults: true

triggers:
  - id: webhook
    type: io.kestra.plugin.core.trigger.Webhook
    key: benchmark

tasks:
  - id: if1
    type: io.kestra.plugin.core.flow.If
    condition: "{{inputs.condition}}"
    then:
      - id: hello-true-1
        type: io.kestra.plugin.core.log.Log
        message: Hello True 1
    else:
      - id: hello-false-1
        type: io.kestra.plugin.core.log.Log
        message: Hello False 1
  - id: if2
    type: io.kestra.plugin.core.flow.If
    condition: "{{inputs.condition}}"
    then:
      - id: hello-true-2
        type: io.kestra.plugin.core.log.Log
        message: Hello True 2
    else:
      - id: hello-false-2
        type: io.kestra.plugin.core.log.Log
        message: Hello False 2
  - id: if1-3
    type: io.kestra.plugin.core.flow.If
    condition: "{{inputs.condition}}"
    then:
      - id: hello-true-3
        type: io.kestra.plugin.core.log.Log
        message: Hello True 3
    else:
      - id: hello-false-3
        type: io.kestra.plugin.core.log.Log
        message: Hello False 3
  - id: if4
    type: io.kestra.plugin.core.flow.If
    condition: "{{inputs.condition}}"
    then:
      - id: hello-true-4
        type: io.kestra.plugin.core.log.Log
        message: Hello True 4
    else:
      - id: hello-false-4
        type: io.kestra.plugin.core.log.Log
        message: Hello False 4
  - id: if5
    type: io.kestra.plugin.core.flow.If
    condition: "{{inputs.condition}}"
    then:
      - id: hello-true-5
        type: io.kestra.plugin.core.log.Log
        message: Hello True 5
    else:
      - id: hello-false-5
        type: io.kestra.plugin.core.log.Log
        message: Hello False 5

Results for Kestra OSS (Postgres)

Results for Kestra EE (RabbitMQ + Postgres)

Key takeaways

• At 200 executions/min (1000 tasks/min), execution latency is approximately 400ms — similar to a single execution time.
• Kestra OSS (Postgres backend) sustains up to 1200 executions/min (6000 tasks/min) with an execution duration of less than 2s, which is what we could realistically target for such a workflow.
• Kestra EE (RabbitMQ + Postgres backend) sustains the same peak throughput as OSS at lower latency.
• The Kestra Executor processing capability is independent of the type of tasks to process; the number of tasks per minute sustained in this benchmark is of the same level as in the first benchmark.

Benchmark 3 — large Loop task

Description Executes 100 iterations of a Loop task with unbounded concurrency.

id: benchmark03
namespace: benchmarks

tasks:
  - id: foreach
    type: io.kestra.plugin.core.flow.Loop
    values: "{{range(1, 100)}}"
    concurrencyLimit: 0
    tasks:
      - id: output
        type: io.kestra.plugin.core.output.OutputValues
        values:
          some: value

Observations The Loop task is executed once, so the flow results in 101 task executions.

On average, the execution time for both backends is around 1.5s, equivalent to approximately 67 tasks/s or 4020 tasks/min. As each loop iteration runs inside a dedicated sub-execution, the overhead is expected for an iteration with a single task.

Benchmark 4 — realtime trigger with JSON transformation

Conclusion

Kestra is a platform, not just a framework. It provides orchestration plus logging, metrics, retries, SLAs, error handling, governance, and observability. While this adds overhead compared to lightweight tools, performance is balanced with feature richness.

Kestra is designed for high performance in workflow orchestration and task dispatching, ensuring minimal time spent in the orchestrator and more time in actual task execution. Thanks to continuous performance tuning by the engineering team, Kestra remains among the fastest, most high-performing workflow orchestrators in every release.

Kestra is built to scale horizontally. When a use case demands it, add Executor/Worker nodes to increase throughput.