Inngest

What Inngest actually is

Inngest is a durability layer for background code. It is not a host, not a queue you run, and not a functions-as-a-service runtime — it is a managed platform that makes event-driven functions reliable: automatic retries with backoff, step-level checkpointing, sleeps that last days or weeks, fan-out, debouncing, rate limiting, and per-tenant concurrency control, all without you operating Redis, a broker, or a worker fleet. You write ordinary functions in your existing codebase (deployed on Vercel, your Kubernetes cluster, a VPS, wherever), and Inngest invokes them over HTTPS when events fire or schedules trigger.

That architecture is the key thing to understand before comparing it to anything in /category/serverless-platforms. Your code keeps running on infrastructure you already own; Inngest's cloud handles the orchestration state. The trade is explicit: you give up owning the queue layer and gain an execution model where a function can pause mid-run (step.sleep(), step.waitForEvent()) for up to 30 days on the free plan and 366 days on Business, resume exactly where it left off, and fan out thousands of child runs — without a single long-lived server holding state.

The company was founded in 2021 and is based in San Francisco. It raised a $3M seed led by GGV Capital with Guillermo Rauch and Tom Preston-Werner participating, then $6.1M led by a16z in 2023. The server itself is open source (roughly 7,100 GitHub stars as of late 2026, with SDKs for TypeScript, Python, Go, and Kotlin plus an agent toolkit), and a self-hosted version exists for teams that want the execution engine inside their own perimeter. Production customers named publicly include SoundCloud, Tripadvisor, ElevenLabs, Cohere, Replit, and Resend — a credible set of references for a company this young.

In our view Inngest belongs in the same mental bucket as Temporal, Hatchet, or a hand-rolled Celery-plus-Redis stack, but aimed at product developers rather than platform teams. The promise is that "reliable background job" stops being an infrastructure project and becomes a function signature.

Pricing: what you really pay

There is a genuinely free plan: $0/mo, no credit card, 50,000 executions per month, 500,000 events ingested, 5 concurrent steps, 5 seats, and 24 hours of trace history. When you hit the free quota, executions pause — they do not bill overage and do not silently charge you. That is a clean, honest free tier, and we wish more infrastructure vendors handled overruns this way.

The catch is the unit of billing. Inngest counts executions as runs x (steps + 1): a five-step function burns six executions per run. The 50,000-execution free quota is therefore 50,000 simple runs, but only about 4,500 runs of a ten-step agent workflow. Read the quota as steps, not runs, and the pricing makes sense.

Paid plans start at $99/mo for Pro (1M executions, 100 concurrent steps, 7-day traces, 90-day max run length), then $499/mo for Business (10M executions, 500 concurrent steps, 14-day traces), with Enterprise custom. Pro overage runs from $0.000050 per execution down to $0.000015 at volume, and extra concurrency beyond 100 concurrent steps is $25 per 25 steps. Events, span data, and "scores" (their evaluation product) meter separately.

The $0-to-$99 jump is the rough edge. Free caps — 5 concurrent steps, 24-hour traces, 3 connected workers, 30-day max run length — can force the upgrade long before you approach 50k executions, and $99 is real money for a side project. Once you are on Pro and pushing volume, the per-run economics are good: at 500k scheduled runs of a one-step job, Pro costs effectively $0.0002 per run, far below per-task pricing on most competitors. Our practical read: hobby projects and prototypes ride free comfortably; anything customer-facing should budget for Pro from day one.

Self-hosting the open-source server costs nothing in license fees, but you run Postgres and Redis yourself and give up the managed observability, so it is a real operational commitment, not a free lunch.

Performance & infrastructure

Here is where our usual ServerSpotter lens barely applies: you do not buy cores, RAM, or disks from Inngest, and there are no instance specs to compare. The functions execute on your infrastructure — your serverless platform, your VMs, your containers. What Inngest runs is the control plane: event ingestion, queues, state, scheduling, and the flow-control layer (virtual queues with per-key concurrency limits, prioritization, rate limiting, batching, debouncing).

Consequently, the performance questions that matter are about throughput and latency of that orchestration layer, and the published plan limits are the honest way to size it: Free handles 100,000 queue depth and 256 KiB events; Pro scales to 5M events ingested per month, 1M queue depth, and 3 MiB events; Business goes to 50M events and 10M queue depth. Step concurrency (5 / 100 / 500 by plan) is the usual bottleneck for fan-out-heavy workloads, which is why it is metered as an add-on rather than hidden.

On reliability, the model is strong by design: every step is checkpointed, failures retry with backoff, and completed steps are not re-run on recovery. Inngest publishes real-time observability metrics and replay tooling, and its customer list includes companies running production workloads at meaningful volume. What is missing is a published uptime SLA on Free and Pro — enterprise agreements can include one, but self-serve buyers are trusting a status page and the architecture, not a contract. We would like to see a credit-backed SLA at the Pro tier; until then, treat single-provider orchestration as a dependency worth designing around (the open-source server is the exit path, which softens the lock-in considerably).

We have not benchmarked Inngest against our /benchmarks test rig — our sysbench/fio/iperf3 methodology measures servers, not orchestration platforms — so all performance statements here are editorial reads of published limits and architecture, not measurements.

Where it falls short

The execution-counting model is the first real complaint. "Executions = runs x (steps + 1)" rewards you for writing fewer, larger steps and quietly punishes good step decomposition — an agent wrapping ten tool calls in steps eats eleven executions per run. Inngest documents this clearly (their pricing page ships a calculator), so it is not deceptive, but it is a pricing model you must model before you commit, and it diverges from competitors that count task runs.

Second, the free-to-Pro cliff. Five concurrent steps is tight enough that a modest fan-out or a second busy app pushes you to $99/mo, and paid add-ons (Datadog export, HIPAA, extra concurrency) stack on top of the base price. Third, this is a developer tool, not infrastructure: if you were shopping for servers in /category/vps-providers, Inngest is not your answer — it assumes you already have somewhere to run code. Fourth, platform depth is bounded by plan: three workspaces and five apps on Free, ten on Pro, 24-hour trace history on Free. Teams with many services will feel those walls.

Finally, there is vendor risk to price honestly. Inngest is a venture-backed, ~30-person company in a category where the incumbent (Temporal) is open source and the hyperscalers keep shipping native schedulers. The MIT-style open-source server is the mitigation — you can run it yourself if the business changes — but self-hosting is a fork-in-the-road you want to have thought about before production, not after a pricing email.

Who should pick this

Our pick for full-stack and product engineers adding background jobs, webhooks, scheduled tasks, or multi-step AI-agent workflows to an existing app — especially on Next.js, Node, Python, or Go stacks — who want retries, sleeps, and fan-out without building a queue platform. If your team's alternative is "a Redis list and a cron job nobody owns," Inngest is a good trade.

We would not pick it for teams that need to own the entire execution path for compliance reasons without self-hosting, for high-volume batch processing where per-task pricing elsewhere is cheaper, or for anyone who just needs a simple job runner — a well-configured Celery or Sidekiq setup on one of our /benchmarks VPS picks costs a fraction at low volume. And if you need a contractual uptime SLA on a self-serve plan, look at enterprise-oriented workflow platforms instead.

Key takeaways

• Durability layer for background code: retries, step checkpointing, sleeps up to 366 days, fan-out, and flow control, invoked over HTTPS on infrastructure you already run.
• Genuine free tier: $0/mo with 50,000 executions, no credit card, and executions pause (no surprise overage) at the quota.
• Billing counts executions as runs x (steps + 1) — step-heavy workflows consume quota far faster than "50k" suggests; model it before committing.
• Pro starts at $99/mo (1M executions); at real volume the per-run cost is low, but the free-to-Pro cliff is steep for small projects.
• Open-source server (self-hostable) plus SDKs in TypeScript, Python, Go, and Kotlin; founded 2021, a16z-backed, with SoundCloud, Tripadvisor, and ElevenLabs as public references.
• No published uptime SLA below enterprise agreements, and no infrastructure specs to tune — the bottleneck is plan limits like concurrent steps, not hardware.

Sources

• https://inngest.com/pricing
• https://inngest.com/docs/durable-execution/limits
• https://inngest.com/
• https://inngest.com/blog/announcing-funding-from-a16z
• https://inngest.com/blog/announcing-inngest-seed-financing
• https://dealroom.co/companies/inngest
• https://omniyond.com/blog/inngest-pricing
• https://shortlisted.tools/products/inngest