Theme

Workflow orchestration

1 repo reviewed · since Nov 17, 2026 · updated Nov 17, 2026 · rewritten each time a repo joins

In one paragraph

Workflow orchestration engines run background jobs and multi-step functions so a crash or a failed call does not lose the work. You describe the steps, and the engine keeps the queue, retries and run state. inngest does this with a server that calls your own code over HTTPS, so you do not run workers. Each step is retried and its output saved.

What counts here: engines that run background jobs and multi-step functions durably, with queues, retries and state handled for you.

The main approaches

Durable execution engines

You write a function in ordinary code and split it into steps. The engine saves each step’s result, retries a step that fails, and resumes the run from the last saved step instead of starting over. Queues, scheduling and run state live in the engine, not in your app.

inngest is written in Go and can be self-hosted. A function has triggers (events, cron or webhooks), flow control and steps. Flow control covers concurrency, throttling, debouncing, rate limiting and prioritization. Steps are wrapped in step.run. Other step types include waitForEvent, and runs can be cancelled with cancelOn expressions. The server calls your app over HTTPS, so your code can run on serverless, servers or the edge. The server itself has an Event API, an event stream, a Runner, a multi-tenant queue, an Executor and a state store.

Map of the theme

flowchart LR
  t["Workflow orchestration"]
  t --> f1["Durable execution engines"]
  f1 --> r1["inngest/inngest"]

Where the new ideas are

  • inngest: the engine owns the queue and state and invokes your functions over HTTPS. Each step.run call in plain code is retried and checkpointed, so you run no worker infrastructure of your own. Flow control such as per-user concurrency limits is declared on the function itself.

Side by side

RepoApproachTriggersFlow controlStep handling
inngest/inngestDurable execution enginesEvents, cron, webhooksConcurrency, throttling, debouncing, rate limiting, prioritizationstep.run retries a failed step and saves its output; waitForEvent and cancelOn supported

How the idea moved

flowchart LR
  n1["started Jun 2021<br/>inngest/inngest"]
  • started Jun 2021 · inngest · Adds: keeps queues, scheduling and run state in a server that calls your functions over HTTPS, so each step.run call in ordinary code is retried and checkpointed without worker infrastructure on your side.

Easily confused

  • A plain job queue. Inngest does more than hand a job to a worker. It tracks progress inside a multi-step function, retrying a failed step and saving each step’s output.
  • A message broker or event bus. Inngest does take events as triggers, but its job is to run functions in response, with retries and saved state, not only to deliver messages.
  • A cron scheduler. Cron is one kind of trigger. The engine also handles events, webhooks, flow control and long-running state.

Gaps nobody has filled

  • No throughput or latency numbers for the queue and executor under load.
  • No account of what happens to runs already in flight when the function code changes.
  • No described way to invoke work over anything other than HTTPS calls into your app.
  • No comparison of the cost or operational load of self-hosting the engine against running your own workers.