Cheapest platform as job volume grows
Steps, duration and machine held at your current inputs โ only monthly job runs change per row. Watch where Trigger.dev's metered total and QStash's per-message bill cross Inngest's flat $0/$99 step function, and where QStash's fixed plans kick in.
| Job runs / mo | Inngest | Trigger.dev | QStash | Cheapest |
|---|
Why flat-tier, per-second-compute and per-message billing shapes matter
Background job and queue platforms don't compete on a single price โ each meters a completely different dimension of your workload. Inngest bills executions = runs ร (1 + steps per run) against flat tiers: free for up to 50,000 executions/month, a flat $99/month covering up to 1,000,000 on Pro, then custom metered overage that Inngest doesn't publish a fixed rate for (self-serve to 20M, then Enterprise) โ so cost doesn't move at all with how long each step takes to run. Trigger.dev instead bills (runs ร duration seconds ร machine $/sec) + (runs ร $0.000025), drawn from a monthly credit ($5 free, $10 on Hobby, $50 on Pro) with any usage above that credit billed at the same metered rate โ so a 4 vCPU Large 1x machine running for 10 seconds costs roughly 20x more than a 0.25 vCPU Micro machine for the same 10 seconds, and duration matters enormously. QStash goes a third direction: messages ร $0.00001 (plus $0.05/GB bandwidth above 50GB free) with no compute metering whatsoever, or a flat monthly plan ($180 for up to 1M messages/day, $420 for up to 10M/day) once pay-as-you-go would cost more โ it only cares how many messages you route, never how long your handler takes to process them.
That means the "cheapest" tool flips depending on your workload shape. A high-frequency, short-duration job (a few hundred milliseconds each) often favors Trigger.dev's metered compute or QStash's flat per-message rate over Inngest's flat tiers. A moderate, predictable volume of multi-step functions with longer-running steps often favors Inngest, since its price is indifferent to duration. And a pure message-routing/webhook-relay workload with no real compute of your own almost always favors QStash, since Inngest and Trigger.dev both charge for the execution itself. Run your own numbers above instead of trusting a vendor's headline plan price.
How this calculator works
The Inngest vs Trigger.dev vs QStash Cost Calculator compares three background-job/queue pricing shapes โ Inngest (flat tiers by execution count), Trigger.dev (per-second compute by machine size + per-run invocation fee, drawn from a monthly credit) and QStash (pure per-message rate, or a flat plan at high volume) โ at your monthly job runs, steps per run, average execution duration, machine size and message payload size. Inngest's cost is a step function: $0 up to 50,000 executions, a flat $99/mo up to 1,000,000 executions, then undisclosed custom overage above that. Trigger.dev's cost is max(plan minimum, (runs ร duration ร machine rate) + (runs ร $0.000025)), since its $0/$10/$50 plan fees are pre-paid usage credits, not separate charges. QStash's cost is min(messages ร $0.00001 + bandwidth overage, best-fit fixed plan), falling back to $0 under its free daily allowance. The calculator shows all three totals side by side, then a separate table isolates all three vendors across a range of monthly job-run volumes at your current steps/duration/machine settings, so you can see exactly where each platform's ranking flips.
These are representative pricing shapes based on each vendor's published self-serve rates as of August 2026 (Inngest Hobby/Pro tiers from inngest.com/pricing; Trigger.dev machine and per-run rates from trigger.dev/pricing; QStash pay-as-you-go and fixed-plan rates from upstash.com/pricing/qstash), not live vendor quotes. Inngest does not publish an exact per-execution overage rate above its 1,000,000-execution Pro tier โ its own pricing page states overage is billed "at tiered rates" that require contacting sales, so volumes above 1M are shown as custom rather than estimated. All three vendors offer negotiated Enterprise pricing above their published self-serve tiers. Always confirm current pricing directly with the vendor before budgeting.
Frequently asked questions
Is Inngest cheaper than Trigger.dev for background jobs?
It depends on how spiky vs. steady your workload is. Inngest's Hobby plan is free for up to 50,000 executions/month and its Pro plan is a flat $99/month covering up to 1,000,000 executions, with tiered custom overage above that (self-serve up to 20M, then Enterprise) โ so cost is a step function that doesn't move with compute time. Trigger.dev bills per-second compute (from $0.0000169/sec on Micro to $0.00068/sec on Large 2x) plus $0.000025 per run invocation, drawn from a monthly credit ($5 free, $10 on Hobby, $50 on Pro) with overage at the same metered rate โ so it scales smoothly with actual usage. For light, short-duration jobs under roughly 1M executions/month, Inngest's flat $99 often loses to Trigger.dev's metered total; for high-volume workloads that would blow past Trigger.dev's usage-based bill, Inngest's flat fee can look cheap by comparison. Run your own run count, steps and duration through the calculator above.
Why does Trigger.dev charge per compute-second instead of a flat per-execution fee like Inngest?
Trigger.dev runs your task code on managed containers sized by machine type (Micro through Large 2x), so its bill reflects actual CPU/RAM consumed โ a task on a 4 vCPU / 8GB Large 1x machine that runs for 10 seconds costs roughly 20x more compute than the same 10 seconds on a 0.25 vCPU Micro machine, plus a flat $0.000025 per-run invocation fee regardless of machine. Inngest instead counts executions (the function run itself plus each step.run() call), so a 5-step function costs the same whether each step takes 200ms or 20 seconds โ it doesn't meter compute duration at all. That makes Trigger.dev cheaper for many short, lightweight jobs and Inngest cheaper for jobs with long-running or heavy steps, since Inngest's per-execution price doesn't change with duration.
When does QStash's fixed-volume plan beat pay-as-you-go?
QStash's pay-as-you-go rate is $1 per 100,000 messages ($0.00001/message) plus $0.05/GB of bandwidth above a 50GB free allowance, with a free tier covering 1,000 messages/day (about 30,000/month). The break-even against the Fixed 1M plan ($180/month, up to 1,000,000 messages/day) lands around 18 million messages/month โ below that, pay-as-you-go is cheaper; above it, the flat $180 wins as long as you stay under the 1M/day cap. The Fixed 10M plan ($420/month, up to 10,000,000 messages/day) becomes the better deal once pay-as-you-go would exceed $420, around 42 million messages/month, or whenever daily volume exceeds the Fixed 1M plan's cap. Every failed delivery attempt that triggers a retry counts as an additional billed message on all plans.
Which is cheapest โ Inngest, Trigger.dev or QStash?
There's no universal winner because the three don't meter the same thing. Inngest wins for predictable, moderate workloads that fit inside its flat $0/$99 tiers regardless of how long each step runs. Trigger.dev wins for lightweight, high-frequency jobs where per-second compute plus a small per-run fee stays below Inngest's flat tiers. QStash wins when you're simply routing messages/webhooks with no compute logic of your own to bill โ its pure per-message price (or flat fixed plan at high volume) ignores execution time entirely. Run your own monthly job volume, steps per run, average duration and machine size through the calculator above instead of assuming a vendor's headline plan price applies to you.