Skip to content
Engineering deep-divesAll articles

Inngest vs Trigger.dev in 2026: Queues, Agents & TCO

Engineering and 36-month TCO teardown of Inngest vs Trigger.dev in 2026 alongside Hatchet and BullMQ: serverless HTTP step push vs checkpointed container tasks, PostgreSQL 17 SKIP LOCKED outboxes, and owned VPC math.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 19 minHow we write →
On this page
Idealogic 2026 engineering comparison of Inngest vs Trigger.dev, Hatchet, and BullMQ covering serverless HTTP step execution, checkpointed container workers, PostgreSQL 17 SKIP LOCKED outbox durability, and 36-month TCO

TypeScript teams shipping webhooks or AI agents reach the Inngest vs Trigger.dev decision early. Inngest runs your steps by calling your HTTP endpoint; Trigger.dev runs them in its own containers. The same teams often weigh Inngest vs BullMQ too, once durable TypeScript workflows start to cost real money.

Our Temporal vs Airflow orchestration guide compares deterministic replay against lakehouse DAGs. This one covers the serverless and container queue tier behind Next.js and Node.js SaaS apps. Managed SDKs are cheap at 50,000 monthly executions. An AI agent that chains 14 tool calls per run across 3,000,000 workflows generates 45,000,000 step executions, though. At that volume the $99/mo plan becomes about $1,374 a month at Inngest list price, and roughly $50,000 a year in our modeled enterprise scenario with HIPAA add-ons.

At Idealogic, our SaaS development, AI agent development, JavaScript development, and custom software development teams ship Inngest, Trigger.dev, Hatchet, and owned BullMQ engines across fintech, healthtech, and logistics and supply chain systems. Below: how the four runtimes differ, a PostgreSQL 17 SKIP LOCKED, FORCE RLS and BullMQ blueprint for durable workflows, and a 36-month total cost of ownership (TCO) model at 45M monthly step executions.

The short version

  • Inngest fits serverless HTTP push and event fan-out. Inngest pushes durable steps (step.run, step.sleep, step.waitForEvent, step.ai.infer) back to your Next.js/Vercel or ECS HTTP routes. Free covers 50k executions and 5 concurrent steps, Pro is $99/mo for 1M executions and 100 concurrent steps, and Business starts from $499/mo for 10M executions and 500 concurrent steps.
  • Trigger.dev fits long-running container and binary tasks. Trigger.dev v4 (Apache-2.0) runs task() code in isolated containers with FFmpeg, Playwright or Python, has no HTTP timeout ceiling, and stops compute billing during long checkpointed wait.forToken() pauses. Plans: Free ($5 credit), Hobby ($10/mo), Pro ($50/mo), plus $0.000025 per run and per-second vCPU/GB.
  • Hatchet (MIT) is the open-source middle option: persistent gRPC workers on a PostgreSQL-backed queue, 1M free Cloud runs a month, then $30 per 1M runs with no charge for retries.
  • Watch the Runs x (Steps + 1) multiplier. 3M monthly agent runs averaging 14 checkpoints consume 45M executions on step-metered clouds. CPU-heavy media or browser tasks hit the per-second vCPU bill instead.
  • At 45M monthly step executions with a HIPAA BAA, an owned VPC engine saves $21.3k to $88.8k over 36 months in our model. The owned PostgreSQL 17 outbox + BullMQ engine ($104,700) comes in under self-hosted Trigger.dev on EKS ($126,000), Trigger.dev Cloud ($182,760), and Inngest Enterprise ($193,500, which includes quote-only add-ons we had to estimate).

2026 architecture internals: Inngest vs Trigger.dev, Hatchet & Owned BullMQ

Two platforms running identical 3,000,000 monthly workflows can produce very different bills, because each runtime puts compute, state replay, and the network boundary in a different place.

Four structural and commercial boundaries separating Inngest HTTP step push, Trigger.dev container workers, and owned VPC PostgreSQL 17 + BullMQ engines in 2026

1. Inngest: Serverless HTTP step push, event fan-out & step.ai.infer

Inngest is a durable workflow service that needs no worker pods or Dockerfiles on your side, which is why it suits Next.js teams:

  1. HTTP push execution (/api/inngest). Your TypeScript, Python, or Go app exposes a signed HTTPS endpoint. When an event arrives, Inngest invokes your route over HTTP. Each durable step primitive (step.run, step.sleep, step.waitForEvent) persists its JSON output in Inngest's state store, and Inngest re-invokes your route for the next step while replaying prior outputs from cache.
  2. Serverless HTTP ceilings and step.ai.infer. Your host runs step.run, so each step obeys the platform's HTTP timeout. Vercel function limitations cap standard routes unless you raise them to 300s to 800s with Vercel Fluid Compute. Inngest step.ai.infer offloads slow LLM calls to Inngest's infrastructure so they sit outside your serverless timeout (TypeScript and Python SDKs only), and Inngest Realtime can stream run updates to UIs.
  3. Pub/sub fan-out and execution math. One event fans out to several functions with per-tenant concurrency, throttling, and debounce. If you outgrow that into a streaming log, see Redpanda vs Kafka. Billing follows Executions = Runs * (Steps + 1). Pro overage is tiered from $50 down to $15 per 1M executions, Business overage is $25 per 1M, Enterprise is quote-only, and the HIPAA BAA is a separate paid add-on.

2. Trigger.dev v4: Container workers, checkpoint/resume & no HTTP ceiling

Trigger.dev is an Apache-2.0 task runner that executes your code in its own containers. v4 is the current line and v3 is legacy (see the migration guide). In a trigger.dev vs inngest comparison it's the pick when serverless HTTP timeouts or missing binaries block a backend task:

  1. Isolated container workers (task()). Trigger.dev packages Trigger.dev tasks into isolated Docker containers, from Micro (0.25 vCPU) to Large 2x (8 vCPU / 16 GB). Runs aren't bound to an HTTP request (a configurable maxDuration still applies), and build extensions cover FFmpeg, Playwright, Sharp, and Python.
  2. Checkpointed waits that don't bill compute. Calling batchTriggerAndWait() or Trigger.dev waitpoints (wait.for and wait.forToken) snapshots the container and suspends the process. Compute billing pauses during long checkpointed waits, so a 72-hour human approval of an AI action costs nothing in idle vCPU. Waits shorter than about 5 seconds aren't checkpointed.
  3. Apache-2.0 source and vCPU billing. The Trigger.dev codebase is Apache-2.0 licensed with Docker and Kubernetes self-hosting. Pro ($50/mo) includes 200+ concurrency and PrivateLink, the Hobby and Pro fees double as usage credit, and extra concurrency is $10/mo per 50. Usage bills at $0.000025 per task run ($25 per 1M) plus active machine seconds: $0.0000338/s on Small 1x, $0.0000850/s on Medium 1x.

3. Hatchet vs Owned VPC Durable Engine (PostgreSQL 17 SKIP LOCKED + BullMQ)

If you're looking for Inngest alternatives or Trigger.dev alternatives, the realistic shortlist is Hatchet, BullMQ on your own Redis, and Temporal (see the checklist at the end).

  • Hatchet (MIT Postgres queue and DAGs). Hatchet's engine is an open-source durable queue backed by PostgreSQL that streams tasks over gRPC to your workers. Cloud gives 1M free runs a month, then $30 per 1M runs, and retries aren't billed.
  • Inngest vs BullMQ and owned VPC durability. Raw BullMQ is a fast Redis job queue (throughput depends on payload and hardware, so benchmark your own), but it has no atomic enqueue with your database and no step memoization inside a job. Pair a PostgreSQL 17 transactional outbox and a step checkpoint table with BullMQ and you get step.run replay and container runtime you control, all inside your VPC, with no per-step fee.

Inngest pricing and Trigger.dev pricing in November 2026

List prices come from each vendor's public pricing page. Enterprise tiers are quote-only.

DimensionInngest (2026)Trigger.dev v4Hatchet (MIT / Cloud)Owned (PG17 + BullMQ)
Execution modelServerless HTTP pushCheckpointed containersgRPC pull workersIn-VPC Node/TS pods
Step timeoutHost HTTP (60s to 800s; step.ai offload)No HTTP ceiling (configurable maxDuration)Configurable task timeoutsYou set it (full pod control)
Native binariesServerless bundle onlyFFmpeg, Playwright, PythonFull worker containerFull Docker / GPU control
OSS licenseSource-available (SSPL, delayed Apache 2.0)Apache-2.0 (K8s self-host)MIT (Postgres self-host)Your own code (MIT BullMQ + PostgreSQL)
Cloud pricing$0 Free; $99 Pro; from $499 Business$0 Free; $10 Hobby; $50 Pro + vCPU-s1M free, then $30 per 1M runsAbout $975/mo AWS HA
HIPAA & VPCCloud logs; BAA is a paid add-onCloud pods; BAA add-on ($500/mo)Cloud or VPC; HIPAA on custom plans (get the BAA in writing)In-VPC on HIPAA-eligible AWS services under the AWS BAA & PCI DSS v4.0.1

Owned durable workflow engine: PostgreSQL 17 outbox, RLS and BullMQ step memoization

Fintech, healthcare, and logistics platforms at scale (see event-driven architecture and multi-tenant SaaS) move off hosted orchestrators for three reasons:

  1. PHI/PII stays in your VPC. Hosted step engines cache serialized step outputs in the vendor's cloud. Keep the checkpoints in your own PostgreSQL and that sub-processor drops out of the data path.
  2. Outbox commits. When the order row and the workflow run row commit in one ACID transaction, a Redis failover can't lose the record that work is due, and you can replay from it. PostgreSQL and Redis still aren't one transaction, so duplicates can happen. A deterministic BullMQ jobId and idempotent steps absorb them.
  3. Idempotent step replay. A checkpoint table returns completed steps from Postgres in single-digit milliseconds inside the VPC (measure it on your workload), so a retry doesn't charge Stripe or call the LLM a second time.

The engine runs on PostgreSQL 17 and combines PostgreSQL FOR UPDATE SKIP LOCKED with PostgreSQL Row-Level Security. The same design works unchanged on PostgreSQL 18. These are the decisions that matter:

Design decisionEnforced inWhat it prevents
Run row written in the same transaction as the business row, unique on tenant, workflow name and idempotency keyDatabaseLost work after a Redis failover and duplicate runs from a double submit
Relay drains pending runs in batches of 100 with FOR UPDATE SKIP LOCKED and enqueues each one under a jobId built from the run IDDatabase and BullMQTwo relays dispatching the same run, and duplicate jobs when a batch is retried
FORCE ROW LEVEL SECURITY with an AS RESTRICTIVE tenant guard on runs and checkpointsDatabaseOne tenant reading or writing another tenant's workflow state
Separate roles: the relay can only move runs from pending to dispatched, the worker only touches rows for its own tenantDatabaseA compromised relay reading payloads or rewriting step outputs
One checkpoint row per run and step key, and a conflicting insert keeps the first outputDatabaseRe-billing Stripe or an LLM when a worker retries a finished step
Six attempts with exponential backoff from 2 seconds, then the run is marked failed; an approval wait parks the run and frees the workerApplicationEndless retry loops, and workers held open during human-in-the-loop waits

Never skip AS RESTRICTIVE. PostgreSQL ORs permissive policies together, so a second permissive rule added later without a restrictive tenant fence leaks state across tenants. With FORCE ROW LEVEL SECURITY and a NULLIF guard on the tenant session setting, an unset variable fails closed instead of throwing a cast error (see multi-tenant SaaS architecture). Two caveats: superusers and roles with BYPASSRLS still skip the policies, and a malformed non-empty value still throws.

The part that replaces Inngest's step.run is a small memoization wrapper. It looks up a stored checkpoint by run ID and step key and returns it when one exists. Otherwise it runs the step once and inserts the output, and a conflicting insert keeps the first stored output, so a retried step never overwrites a finished one. Every read and write goes through a tenant-scoped transaction.

When an approver resolves a wait token, your API writes the decision as a checkpoint and re-enqueues the run. BullMQ picks the job up within milliseconds, replays the earlier steps from Postgres, and finishes the run. Steps that call Stripe should still send the step key as an Idempotency-Key, because a crash between the API call and the checkpoint insert re-runs that step.

Outgrowing Inngest step quotas, Vercel timeouts, or fragile BullMQ retry glue?
Share your monthly workflow runs, average steps per job, and compliance rules. Our backend architects will benchmark Inngest, Trigger.dev, and an owned VPC outbox engine.
Audit your durable workflow stack

Inngest vs Trigger.dev 36-month TCO model: 45M step executions/mo across 3M multi-step workflows

Take a scaling B2B SaaS or AI agent product over 36 months: 3,000,000 workflows a month averaging 14 internal steps (45,000,000 Inngest executions a month), 1,000 peak concurrent steps or containers, and SOC 2 Type II plus HIPAA BAA governance. LLM API tokens are identical across options and excluded. SaaS and AWS figures are list prices checked in November 2026. Enterprise add-ons are our estimates, since vendors only quote them privately.

Engineering labor uses Idealogic's $75/hr senior CEE rate against a $165/hr US agency rate (2.2x). For context, see the 2025 EU whole-economy hourly labour cost benchmark (lc_lci_lev, EUR 34.9) and the BLS occupational profile for software developers. The rates match our AI agent development cost guide:

  1. Option A: Inngest Business / Enterprise (45M executions/mo, 1,000 concurrency, HIPAA BAA):
    • Initial setup (60 hrs at $75/hr CEE = $4,500; $9,900 at $165/hr US): Typed events, /api/inngest Fluid Compute routes, tenant concurrency keys, and step.ai.infer wiring.
    • 36-month SaaS and step-target compute ($4,800/mo x 36 = $172,800): Business base ($499/mo with 10M executions and 500 concurrency), 35M executions of overage at $25 per 1M ($875/mo), and Vercel Fluid / ECS pods serving 45M HTTP pushes ($650/mo). Two lines are modeled assumptions, because Inngest only quotes them privately: 500 extra concurrency slots ($500/mo) and Enterprise HIPAA BAA, SSO and 90-day traces ($2,276/mo). Add 6 hrs/mo (216 hrs) of ops ($16,200 CEE / $35,640 US) and the total is $193,500 ($218,340 US).
  2. Option B: Trigger.dev Cloud Pro (18M invocations/mo, container vCPU-seconds, HIPAA BAA add-on):
    • Initial setup (80 hrs at $75/hr CEE = $6,000; $13,200 at $165/hr US): Container task() specs, Playwright and Python extensions, wait.forToken() hooks, and PrivateLink.
    • 36-month Cloud spend ($4,460/mo x 36 = $160,560): Grouping fine steps into 3M parent and 15M child subtasks yields 18M invocations (at $25 per 1M = $450/mo) and 40M active Medium 1x (1 vCPU / 2 GB) seconds (at $0.000085/s = $3,400/mo, nothing during waits). The HIPAA BAA add-on is $500/mo and 800 extra concurrent runs cost $160/mo (16 x $10), less the $50 Pro usage credit. Add 6 hrs/mo (216 hrs) of ops ($16,200 CEE / $35,640 US) and the total is $182,760 ($209,400 US).
  3. Option C: Self-hosted Trigger.dev (Apache-2.0) on AWS EKS:
    • Initial setup (240 hrs at $75/hr CEE = $18,000; $39,600 at $165/hr US): Terraform EKS, Coordinator/Supervisor checkpoint daemonsets, ClickHouse, RDS, Redis, ECR, and OTel alerts.
    • 36-month AWS EKS + ClickHouse ($1,650/mo x 36 = $59,400): EKS control plane, Multi-AZ RDS + ClickHouse + Redis, and worker nodes. Add 18 hrs/mo (648 hrs) of SRE upgrades ($48,600 CEE / $106,920 US) and the total is $126,000 ($205,920 US).
  4. Option D: Owned VPC durable outbox + BullMQ engine (PostgreSQL 17 + Redis + TS workers) built by Idealogic:
    • Turnkey build (640 hrs at $75/hr CEE = $48,000; $105,600 at $165/hr US): PostgreSQL 17 SKIP LOCKED outbox + FORCE RLS checkpoints, BullMQ tenant fairness, step.run + waitForToken SDK, replay UI, OpenTelemetry spans (see Langfuse vs LangSmith), and k6 chaos QA, on HIPAA-eligible AWS services under the AWS BAA and scoped for PCI DSS v4.0.1.
    • 36-month AWS (about $975/mo x 36 = $35,100): Multi-AZ RDS PostgreSQL 17 db.r7g.large (about $419/mo), Multi-AZ ElastiCache r7g.large (about $256/mo), and four c8g.large worker pods (about $300/mo), before storage and data transfer, with no per-step fee. Add 8 hrs/mo (288 hrs) of SRE ops ($21,600 CEE / $47,520 US) and the total is $104,700 ($188,220 US).
Worked 36-month workflow TCO at 45M step executions/mo. The bars were drawn before the November 2026 price check. Corrected totals: $193.5k Inngest Enterprise, $182.8k Trigger.dev Cloud, $126k self-hosted EKS, $104.7k owned PG17 outbox + BullMQ engine
36-month line item (45M steps/mo, 1,000 concurrency)Option A: Inngest Ent.Option B: Trigger.dev CloudOption C: Trigger.dev EKSOption D: Owned Outbox EnginePrimary economic driver
1. Initial setup / build (@ $75/hr CEE)$4,500 (60h; $9.9k US)$6,000 (80h; $13.2k US)$18,000 (240h; $39.6k US)$48,000 (640h; $105.6k US)Option D builds VPC engine & replay UI
2. 36-mo SaaS / AWS compute$172,800 ($4,800/mo)$160,560 ($4,460/mo)$59,400 ($1,650/mo EKS)$35,100 (about $975/mo AWS)Removes the 45M step and vCPU SaaS fees
3. 36-mo platform SRE ops (@ $75/hr)$16,200 (6h/mo; 216h)$16,200 (6h/mo; 216h)$48,600 (18h/mo; 648h)$21,600 (8h/mo; 288h)PG17 + Redis halves EKS + ClickHouse ops
Total 36-Month Workflow TCO$193,500$182,760$126,000$104,700 (CapEx incl.)Saves $21,300 to $88,800 over 36 mos
Year-2+ Annual Run-Rate$63,000/yr$58,920/yr$36,000/yr$18,900/yrSaves $17,100/yr to $44,100/yr
VPC Residency & Lock-InCloud state logsCloud containersSelf-hosted Apache-2.0In-VPC state + ACID outboxLess vendor lock-in, no per-step fee

Sensitivity check: Early SaaS velocity vs payback math

  • Seed and Series A (under 5M executions/mo, under $300/mo spend). Rent Inngest Pro ($99/mo) or Trigger.dev Pro ($50/mo plus usage) until retention is proven (see how to build a SaaS).
  • High volume (above about 30M steps/mo, modeled here at 45M, or a HIPAA VPC rule). The extra CapEx over Inngest ($43,500) divided by $3,675/mo in OpEx savings ($5,250/mo vs $1,575/mo) pays back in about 11.8 months. Against Trigger.dev Cloud it's about 12.6 months ($42,000 / $3,335/mo). At $165/hr US labor the owned engine ($188,220) still comes in below the other three options at this volume, though by a much thinner margin.

2026 durable workflow & AI agent queue build costs (Senior CEE vs US)

Our SaaS development, AI agent development, and JavaScript development teams deliver fixed-milestone builds at $75/hr senior CEE against $165/hr US agency rates:

Engagement tierTimelineHoursSenior CEE ($75/hr)US Agency ($165/hr)Scope & deliverables
Inngest / Trigger.dev Sprint2 to 3 wks120 to 220h$9,000 to $16,500$19,800 to $36,300Typed events, step.run / task() flows & alerts
Trigger.dev / Hatchet Self-Host4 to 6 wks240 to 400h$18,000 to $30,000$39,600 to $66,000Terraform EKS/ECS, ClickHouse/PG17 HA & OTel
Owned VPC Outbox Engine (640h)8 to 11 wks560 to 840h$42,000 to $63,000 ($48k)$92,400 to $138,600 ($105.6k)PG17 SKIP LOCKED + FORCE RLS, BullMQ & UI
Regulated FinTech / AI Saga Core12 to 16 wks960 to 1,360h$72,000 to $102,000$158,400 to $224,400Saga rollbacks, agent evals & Temporal/VPC
Dedicated Backend & Agent PodOngoing240h/mo (2 engineers)From $18,000/moFrom $39,600/moSenior TypeScript, Node.js, PostgreSQL & SREs

Inside the worked 640-hour ($48,000 CEE vs $105,600 US) owned worker engine

Worked model, assumptions in text: 640-hour ($48,000 at $75/hr CEE vs $105,600 at $165/hr US) owned PostgreSQL 17 transactional outbox, BullMQ step memoization & HITL engine
  • 1. PG17 Outbox & FORCE RLS (30% / 192 hrs / $14,400 CEE vs $31,680 US): Partitioned workflow_runs and workflow_step_checkpoints, FOR UPDATE SKIP LOCKED relay, AS RESTRICTIVE tenant fences, and archival.
  • 2. BullMQ Step Engine & Fairness (25% / 160 hrs / $12,000 CEE vs $26,400 US): Typed step.run / step.sleep runtime, per-tenant fairness written in Redis Lua (we implement it ourselves instead of buying BullMQ Pro), backoff, and outbound webhooks (see Resend vs SendGrid).
  • 3. HITL Tokens & AI Wrappers (20% / 128 hrs / $9,600 CEE vs $21,120 US): Zero-CPU waitForToken suspension, LLM budget circuit breakers, and Stripe/ERP idempotency adapters (AI agents for business).
  • 4. Replay Admin UI & OTel (15% / 96 hrs / $7,200 CEE vs $15,840 US): Next.js step-output inspector, one-click replay from failed step N, dead-letter triage, and OpenTelemetry spans.
  • 5. Dual-Write Cutover & Chaos QA (10% / 64 hrs / $4,800 CEE vs $10,560 US): Shadow migration, Redis failover drills, SIGTERM drain tests, and 2,500 steps/sec k6 soak tests.

Inngest and Trigger.dev save months before Series A. Once AI agents chain fifteen steps across millions of runs or HIPAA rules block VPC egress, deterministic step keys let you move onto PostgreSQL 17 and BullMQ without rewriting your workflow code.

Artem Zaitsev · CTO at Idealogic

Shipped proof and a 5-step Inngest vs Trigger.dev decision checklist

Two Idealogic builds run this kind of asynchronous worker and multi-party state logic in production:

  • Background worker fleet (Pressmerit). A standalone BullMQ worker service runs the SERP-to-crawl-to-classification candidate funnel and the live-link re-checks behind a metered credit economy.
  • Multi-party signing flows and audit logs (Chaindoc). Used by 500+ organizations for 10,000+ signed agreements at 99.9% verification uptime, with Stripe Connect splits, webhooks, and SHA-256 audit trails.

Five checks cover most Inngest vs Trigger.dev decisions for a TypeScript workflow stack:

  1. Serverless Next.js with event fan-out, steps under 60s, and nobody to run workers? Pick Inngest (Free or $99/mo Pro).
  2. Tasks that need FFmpeg, Playwright, Python, runs over 5 minutes, or long human-in-the-loop waits that shouldn't bill? Pick Trigger.dev v4 ($50/mo Pro or Apache-2.0 self-host).
  3. Want an MIT-licensed, Postgres-backed queue over gRPC? Evaluate Hatchet.
  4. Polyglot microservice sagas? Inngest vs Temporal comes down to this: choose Temporal when you need polyglot sagas with deterministic replay, and accept the heavier cluster. Our Temporal vs Airflow guide covers it.
  5. Past about 30M monthly step executions, or under zero-egress HIPAA / PCI VPC rules? Deploy an owned PostgreSQL 17 outbox + BullMQ engine (about $975/mo on AWS). Contact our team for a 48-hour TCO model.
Scoping Trigger.dev / Inngest or graduating to an owned VPC durable workflow engine?
Send your queue topology, monthly run and step counts, and latency or HIPAA constraints. Our senior CEE architects will return a system spec and fixed-milestone quote within 48 hours.
Request a 48-hour workflow TCO audit

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.

Frequently asked questions

  • Choose Inngest when you don't want to run separate worker infrastructure and your workflows are short steps that Inngest can push over HTTP into the Next.js, Vercel Fluid Compute, or ECS routes you already have. Native multi-subscriber event fan-out is the other reason. Choose Trigger.dev v4 when tasks run longer than serverless HTTP ceilings, need custom Docker binaries such as FFmpeg, Playwright, or Python data libraries, or when Apache 2.0 self-hosting matters to you.

  • Inngest bills per execution, so one workflow run with 14 step.run checkpoints consumes 15 billable executions. Free covers 50,000 executions, Pro is $99 per month for 1 million, and Business starts from $499 per month for 10 million, with overage at $25 per million. Trigger.dev bills $0.000025 per task run plus per-second vCPU and RAM while the task is active. Its plans are Free ($5 credit), Hobby ($10 per month) and Pro ($50 per month), and the Hobby and Pro fees count as usage credit. Compute billing stops during long checkpointed waits.

  • Not for orchestrated multi-step workflows, as long as each individual step finishes inside your platform ceiling, which runs from 60 to 800 seconds on Vercel depending on plan and Fluid Compute settings. Inngest sleeps for days or weeks via step.sleep and step.waitForEvent without holding an HTTP request open, and step.ai.infer offloads LLM calls to Inngest so they don't count against your serverless timeout. A single CPU-bound task you can't split, such as a 25 minute video transcode or a headless browser crawl, still needs Trigger.dev containers or ECS workers.

  • When a Trigger.dev v4 task calls wait.for or wait.forToken to pause for a human reviewer or a webhook callback, or waits on child tasks through batchTriggerAndWait, Trigger.dev snapshots the container's state and suspends the process. You aren't billed for vCPU or RAM while the workflow sleeps for hours or days, and it resumes from the saved state once the approval token resolves. Waits shorter than about 5 seconds aren't checkpointed, so they still bill as active compute.

  • Managed platforms win below about 30 million monthly step executions, because built-in observability and flow control cost less than SRE time. Above that, or when regulated HIPAA and PCI DSS payloads can't transit an external vendor's replay logs, an owned PostgreSQL 17 transactional outbox paired with BullMQ gets cheaper. In our worked model at 45 million monthly executions it cuts 36-month TCO by 43 to 46 percent against the managed clouds.

  • Hatchet is an MIT-licensed, PostgreSQL-backed durable queue and DAG engine. Its workers hold persistent gRPC connections instead of receiving serverless HTTP webhooks, and it has SDKs for TypeScript, Python, Go and Ruby. Hatchet Cloud includes 1 million free task runs a month, charges $30 per million after that, and doesn't bill for retries.

  • Durable execution stores the serialized JSON output of each completed step in a checkpoint journal keyed by tenant ID, run ID and a deterministic step key. If step 5 fails on a transient upstream 503, the worker replays steps 1 through 4 from the persisted checkpoint rows instead of calling Stripe, Anthropic or OpenAI again. One caveat: that only holds for steps whose output was checkpointed. A crash between the Stripe call and the checkpoint insert re-runs the step, so pass the step key as a Stripe Idempotency-Key too.

  • A production VPC durable workflow engine takes roughly 640 senior hours: $48,000 at $75 per hour in CEE versus $105,600 at $165 per hour in the US. That covers PostgreSQL 17 FOR UPDATE SKIP LOCKED outbox draining, FORCE ROW LEVEL SECURITY tenant isolation, step checkpoint memoization, BullMQ dispatch, human-in-the-loop tokens and an OpenTelemetry replay UI. It runs on about $975 per month of AWS infrastructure at on-demand list prices.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.