Inngest

Executes multi-step workflows with automatic state checkpointing after each step, enabling resumption from failure points without re-executing completed steps. Uses Redis-backed state management with Lua scripts for atomic queue operations and checkpoint persistence. Steps are defined declaratively and executed sequentially with full execution history tracking via CQRS event storage.

Triggers workflow execution based on incoming events matched against declarative trigger patterns defined in CUE configuration. Events are ingested via REST API or SDK, normalized, and matched against registered function triggers using pattern matching logic. Supports event filtering, batching, and fan-out to multiple workflows from a single event.

Exposes workflow execution data and operations via GraphQL API, enabling flexible querying of executions, functions, and traces. Supports filtering, pagination, and aggregation. Mutations enable triggering executions, canceling runs, and managing function configurations. Uses DataLoader pattern for efficient batch loading to prevent N+1 queries.

Web-based dashboard for monitoring workflow executions, viewing execution traces, and debugging failures. Displays execution timeline, step results, logs, and error information. Supports filtering by function, status, and date range. Includes real-time updates via WebSocket and detailed trace visualization with timing information.

Enables parallel execution of multiple steps using fan-out pattern, where a single step spawns multiple child executions. Fan-in collects results from all child executions and passes them to subsequent steps. Implemented via step functions that return arrays of execution requests. Supports dynamic fan-out based on runtime data.

Command-line interface for initializing new functions, deploying to Inngest, managing function configurations, and running local development server. Supports scaffolding function templates, validating CUE schemas, and generating SDK code. Integrates with version control for tracking function changes.

Provides SDKs for multiple languages (Node.js, Python, Go, etc.) with automatic type generation from CUE schemas. SDKs handle HTTP communication with execution engine, request signing, response validation, and error handling. Generated types ensure type safety across language boundaries.

Automatically retries failed steps using configurable exponential backoff with jitter to prevent thundering herd. Retry logic is built into the execution engine and applied transparently across all step types. Supports max retry counts, custom backoff curves, and retry-specific error classification (retryable vs permanent failures).

Enforces concurrency constraints at multiple levels: global per-function limits (max concurrent executions), and per-key limits (max concurrent executions for a specific entity like user ID or order ID). Uses Redis-backed distributed locking with Lua scripts to enforce limits atomically across multiple execution nodes. Queues excess executions and processes them as capacity becomes available.

Pauses workflow execution at any step and resumes when a specific event is received. Pause state is persisted in Redis with event matching logic; when a matching event arrives, the workflow automatically resumes from the pause point with the event data available to subsequent steps. Supports timeout-based auto-resumption and conditional pause logic.

Executes workflow steps by making HTTP requests to SDK endpoints (user-defined functions), handling request/response serialization, timeout management, and error classification. Uses HTTP/2 with connection pooling for efficiency. Supports multiple SDK implementations (Node.js, Python, Go) via a standardized protocol. Handles response validation, type coercion, and automatic retry on network errors.

Provides a WebSocket gateway that allows SDKs to maintain long-lived connections to the Inngest backend, enabling server-initiated execution requests without polling. SDKs register themselves via WebSocket and receive step execution requests in real-time. Supports automatic reconnection, connection pooling, and load balancing across multiple SDK instances.

Defines workflow functions using CUE configuration language, which provides type-safe schema definition with validation, documentation, and code generation. Function schemas specify triggers, steps, concurrency limits, retry policies, and input/output types. CUE schemas are compiled into efficient validators and used for runtime type checking and IDE autocomplete.

Provides a local development server that executes workflows against a local Redis instance, enabling rapid iteration without deploying to production. Supports hot reload of function definitions and automatic re-execution of failed workflows. Includes a web UI for inspecting execution traces, logs, and step results in real-time.

Records all workflow executions as immutable event streams using CQRS (Command Query Responsibility Segregation) pattern. Every step execution, pause, resume, and state change is recorded as an event. Events are stored in append-only log and used to reconstruct execution state, generate traces, and enable audit trails. Traces include timing, error information, and full execution context.