A year ago, “durable execution” was a term you’d hear mostly from Temporal engineers and a few backend nerds at conferences. Today every TypeScript shop building an AI agent ends up needing it. The minute your LLM call has to retry across hours, your webhook fan-out has to survive a deploy, or your multi-step tool use has to recover from a flaky third-party API, your Redis-and-cron setup falls over.
I’ve shipped production workloads on all three of the obvious candidates — Trigger.dev, Inngest, and Temporal — and I keep getting asked which one to pick. Short answer: it depends on what you’re optimizing for. Long answer is the rest of this post.
Why this category suddenly matters
The AI-agent boom did something unusual to backend infra: it made boring problems urgent. Retries, idempotency, step-by-step state, replay, observable timelines — none of this is new. Temporal solved most of it back in 2019. But until LLMs entered the picture, most teams could fake their way through with BullMQ, a cron job, and a prayer.
Then agents happened. A single user request now triggers a chain of LLM calls, tool invocations, and external API hits that can take minutes or hours. Each step can fail in genuinely interesting ways — rate limits, malformed JSON, half-finished tool calls. Your code needs to retry the failing step without re-running everything that already succeeded, and it needs to do this without holding a process open for half an hour.
That’s durable execution. The runtime stores the state of every step, retries on failure, and lets you await something that takes three days to resolve as if it were a regular function call. Once you’ve used it, going back feels primitive.
The mental model: queues vs step functions vs workflow engines
Before comparing tools, sort out what category each one falls into. They look similar from a distance and behave very differently up close.
A queue (BullMQ, Sidekiq, SQS) hands a job to a worker. If it fails, you retry the whole thing. Simple, fast, dumb. Fine for “send this email.”
A step function platform (Inngest, Trigger.dev) breaks one logical task into multiple checkpointed steps. Each step’s result is stored. If step 4 fails after steps 1–3 succeeded, only step 4 retries. Sleeps work for hours or days without holding a worker. This is the sweet spot for AI agents and webhook fan-out.
A full workflow engine (Temporal) gives you the same checkpointed-steps model plus deterministic replay, signals, child workflows, sagas, versioning of running workflows, and a real cluster. It’s overkill for a side project and exactly right for a fintech ledger.
Most teams reading this comparison don’t need a full workflow engine. They need step functions with good DX. That’s why Inngest and Trigger.dev are eating Temporal’s lunch in the TypeScript world — not because they’re better engines, but because Temporal’s developer experience for a Node.js team is still rough compared to “npm install and define a function.”
Trigger.dev v3: the DX-first contender
Trigger.dev v3 went open access in early 2024 and has been the fastest-growing of the three since. The core pitch is straightforward: write a TypeScript function, decorate it as a task, and the platform handles retries, queues, scheduling, observability, and elastic compute. Self-hosting is Apache 2.0.
What I like about it is the inversion of the usual serverless tradeoff. You don’t have a 15-minute Lambda timeout problem because tasks run on Trigger’s managed workers (or your own), not on Vercel’s serverless functions. You can checkpoint mid-task, sleep for days, fan out to subtasks, and watch the whole thing replay in their dashboard. The dashboard, honestly, is the best in the category.
Pricing as of May 2026: Free includes $5 of monthly usage. Pro is $50/month with $50 of usage included, 100+ concurrent runs, and unlimited tasks. Pay-per-run is genuinely cheap if you stay under a few million executions a month. They dropped the price on extra concurrency in late 2025 and made it self-serve, which removed the only real friction point I’d had with them earlier.
The catches: the managed cloud has had two notable outages I’m aware of since 2024, and self-hosting v3 is doable but not as trivial as the docs suggest — you’re running multiple containers, a Postgres, and Redis. If you’re going to self-host, plan to dedicate someone to it for a sprint. The realtime APIs and React hooks are nice for streaming agent progress to a UI, and that’s the feature I keep reaching for on AI projects.
Inngest: event-driven, Vercel-friendly, Pro is $75
Inngest takes a different shape. Instead of “call this function and let it run,” you publish events and Inngest fans them out to functions that have subscribed. Functions are step-function-shaped: each step.run is a checkpoint, step.sleep parks the workflow without holding a worker, step.waitForEvent blocks until a related event arrives. This event-first model is excellent for SaaS workflows — user signs up, fire user.signup, have onboarding, billing setup, and welcome emails all listen independently.
The DX is genuinely good. You write functions in your existing Next.js or Express codebase, deploy them like normal, and Inngest’s cloud dispatches invocations to your endpoints. Vercel teams especially like this because there’s nothing new to operate — your functions live where your app already lives. The flip side: your serverless function timeout still applies to each step, so steps must be quick. Long-running computation or large LLM calls require thinking about chunking.
Pricing as of May 2026: Hobby is free with 100,000 executions per month. Pro starts at $75/month and includes more executions, granular metrics, and longer trace retention. Beyond the included tier you’re paying around $50 per million additional executions — competitive but watch how Inngest counts steps as separate billable executions, because a 10-step workflow is 10 charges. For workflow-heavy AI agents this matters more than the headline price suggests.
There’s an open-source self-hostable Inngest server, but the Cloud is where the real product lives. Self-hosting is fine for development and small workloads; if you need the enterprise features (observability, replay, throttling controls), the cloud is effectively required. For teams that prefer “no new infra,” that’s a feature, not a bug.
Temporal: the heavyweight that actually deserves the reputation
Temporal is in a different weight class. It’s the open-source descendant of Uber’s Cadence, used in production by Netflix, Snap, Stripe, and roughly half the fintech companies you can name. The programming model is deterministic — your workflow code can replay from history at any time, which means you can pause a workflow mid-execution and resume it after a deploy, version it, signal it from outside, and inspect its full history with absolute fidelity.
That power costs you something. The mental model is harder. Workflow code can’t do non-deterministic things directly (no Date.now(), no random numbers, no I/O — those go through activities). The SDK is excellent in TypeScript and Go, decent in Java and Python, and you’ll spend a real week getting comfortable with the abstractions. Operating a self-hosted cluster is doable but expects you to understand Cassandra/Postgres tuning, persistence, and matching service shards. Most small teams should not self-host.
Temporal Cloud as of May 2026: Essentials is the greater of $100/month or 5% of your consumption. Growth is $200/month with 1 million Actions included. Actions are the billable unit — starting a workflow, sending a signal, recording a heartbeat all count. Add-on Actions sit around $50 per million on Essentials, with volume discounts as you scale. Business is roughly $2,000/month with priority support and SLAs. Enterprise is custom.
Where Temporal earns its keep: anything where correctness matters more than DX. Payments orchestration, ledger sagas, multi-stage human approval flows, anything you’d be comfortable putting in front of an auditor. The replay debugger alone has saved me from production incidents that would have been impossible to reconstruct on Inngest or Trigger.dev. If you’re at the scale where a botched workflow costs real money, Temporal is the answer.
Cost at three scales
Real numbers, May 2026, assuming a typical agent workload (~5 steps per user request, modest sleeps, no heavy compute).
10,000 runs/month (small SaaS, side project)
- Trigger.dev: ~$5 (free tier, maybe Pro for the concurrency headroom)
- Inngest: $0 (under 100k executions even with 5 steps)
- Temporal Cloud: $100 minimum (Essentials floor)
For something this small, Temporal’s pricing makes no sense. Pick Inngest or Trigger.dev.
1,000,000 runs/month (real product, decent traffic)
- Trigger.dev: ~$50–$150 depending on compute machine size and concurrency
- Inngest: ~$75 base + ~$200 in step overage if you hit 5M step executions
- Temporal Cloud: $200/month (Growth tier covers 1M actions; multi-step workflows push this higher)
This is the most contested bracket and where pricing genuinely matters. Inngest’s per-step billing punishes long workflows; Trigger’s per-second compute billing punishes long-running tasks. Read your real workload before picking.
100,000,000 runs/month (you have a team and a CFO)
- Trigger.dev: enterprise pricing, expect a custom contract
- Inngest: enterprise pricing, expect a custom contract
- Temporal Cloud: enterprise pricing, expect a custom contract — or self-host the cluster
At this scale the sticker price is a starting point for negotiation. The interesting question isn’t “what does it cost” but “what does it cost when it’s down.” Temporal’s track record under load is the strongest of the three. Inngest and Trigger.dev are catching up, but neither has a decade of nine-figure-volume customers.
Decision matrix
I keep this table in my head when teams ask. Yours might differ.
- Building an AI agent in a TypeScript stack, want it shipped this week: Trigger.dev. Best DX for the agent loop, realtime hooks for UI streaming, painless setup.
- Webhook fan-out, lifecycle workflows, Vercel-shaped infra: Inngest. The event model is genuinely better for SaaS lifecycle stuff, and the Vercel-native deployment removes a category of operational pain.
- Anything financial, regulated, or where replay-and-audit matters: Temporal. Don’t fight this one — the cluster overhead is worth it the first time you need to reconstruct a state from six months ago.
- Strong preference for self-host, no cloud lock-in: Trigger.dev (Apache 2.0) or Temporal (open-source server). Inngest’s open source is real but the cloud is where the polished product lives.
- Multi-language team (Go + Java + Python): Temporal. The other two are TypeScript-first and the gaps show.
- You already have Step Functions or AWS-native shop: Temporal Cloud is on AWS Marketplace with pay-as-you-go now, which makes procurement easier than the others.
Migration notes from the trenches
BullMQ to Trigger.dev is the most common path I see. The mental model maps cleanly — queue.add becomes task.trigger, your processor function becomes the task handler. The win is mostly observability and the ability to break a job into checkpointed steps without rewriting your whole queue layer. Plan for a week of converting your most-painful jobs first; the rest is gradual.
AWS Step Functions to Temporal is harder than it looks. Step Functions’ state-machine model is declarative and Temporal’s is imperative — you’re rewriting JSON state machines as code. The upside is that the code is testable in ways the JSON never was, and your local dev loop stops requiring AWS calls. Budget two weeks per nontrivial state machine.
Cron + Redis to Inngest is the gentlest migration. Most teams already have events flowing somewhere; you’re just pointing Inngest at them. The real change is mental — moving from “run this job at 2am” to “react when X happens” — and once a team makes that shift, they don’t go back.
What I’d pick for a greenfield 2026 project
If I’m starting a new TypeScript backend today and durable execution is on the requirements list, the answer is Trigger.dev nine times out of ten. The DX is the best of the three for AI-agent work, the pricing is honest, and self-hosting is a real escape hatch if I ever want it. Inngest is a strong alternative if my workloads are event-driven SaaS lifecycle stuff rather than agent loops. I’d reach for Temporal only if I’ve already decided that auditability and replay are first-class requirements — and at that point, the team that’s signing up for Temporal generally knows it.
The one trap I’ve watched teams fall into: picking Temporal because it sounds enterprise-grade and then never using 80% of what they’re paying for. If you’re not running signals, child workflows, sagas, or replay debugging in anger, you bought a Boeing for a grocery run.
Spin up the free tier on whichever one fits your model, port one painful workflow over, and see how the first incident goes. That’s the only benchmark that matters.
Sources: