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.runcall 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
| Repo | Approach | Triggers | Flow control | Step handling |
|---|---|---|---|---|
| inngest/inngest | Durable execution engines | Events, cron, webhooks | Concurrency, throttling, debouncing, rate limiting, prioritization | step.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.runcall 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.