Trigger.dev vs Inngest for Indie Developers (2026)

Verdict: Pick Trigger.dev if your background jobs are long, heavy or awkward to run inside serverless functions (video, scraping, AI agents that run for minutes), because it runs them on its own containers and bills per second, from $0 with $5 of monthly credit. Pick Inngest if you want durable, step-based workflows that live inside your existing app and run on your existing host, with 50k free executions a month and SDKs beyond TypeScript. Both are good; the deciding question is where you want the code to run.

Every price, limit and licence below comes from Trigger.dev's, Inngest's or the other vendors' own pages, checked on 13 Nov 2026. Where we use Trigger.dev's own comparison page, we only take claims about Trigger.dev from it. The advice in between is ours and is marked as such.

TL;DR#

• Execution model. Trigger.dev says "Your code runs on managed compute", with a container per run (Trigger.dev vs Inngest). Inngest calls an HTTP endpoint in your app, usually /api/inngest, or talks to your workers over an outbound WebSocket (Inngest docs).
• Free tiers. Trigger.dev Free: $0, $5 of compute credit a month, 20 concurrent runs (Trigger.dev pricing). Inngest Free: 50k executions a month, 5 concurrent steps, pauses at quota (Inngest pricing).
• First paid step. Trigger.dev Hobby is $10/mo with $10 of credit included. Inngest Pro starts at $99/mo with 1m executions.
• Billing unit. Trigger.dev: per run plus per second of compute. Inngest: per execution, where each run and each step counts.
• Licences. Trigger.dev is Apache 2.0. The Inngest server is under the Server Side Public License with delayed Apache 2.0 publication.

Disclosure: ZeroRaised publishes this comparison and is a launch site for bootstrapped products. ZeroRaised has no commercial relationship with Trigger.dev or Inngest and earns nothing if you sign up for either. Facts come from the linked sources as checked on 13 Nov 2026.

Who this is for#

You have a Next.js or Node app, probably on Vercel, and you have hit the point where some work cannot happen inside a request: sending a welcome sequence, processing an upload, retrying a flaky webhook, running an LLM agent that takes four minutes, or a scheduled sync. You want retries, logs and a dashboard without running Redis and workers yourself. Trigger.dev and Inngest are the two names most indie developers shortlist for that job.

Trigger.dev vs Inngest head to head#

Sources: Trigger.dev pricing, Trigger.dev vs Inngest, Trigger.dev wait docs, Inngest pricing, Inngest serving docs, Inngest local development, Inngest on GitHub, Trigger.dev on GitHub.

The real difference: where the code runs#

This decides most cases, so it is worth being concrete.

Trigger.dev runs your tasks for you. You write a task in TypeScript, deploy it with their CLI, and it runs on Trigger.dev's containers with the CPU and RAM you choose. Your web app only triggers the task. Its comparison page says "Each run gets its own container (configurable CPU/RAM)" (Trigger.dev vs Inngest), and its pricing FAQ says "Runs have no maximum duration" (Trigger.dev pricing). When a task waits, for example on wait.for longer than 5 seconds or on a child task, it is checkpointed and the wait does not count as compute (Trigger.dev wait docs). One caveat from the same docs: "Free compute isn't the same as freed concurrency", so short waits still hold a concurrency slot.

Inngest orchestrates code that runs in your app. You add an endpoint, usually /api/inngest, and Inngest calls it to run each function and each step, storing state between calls (Inngest docs). Your code runs on Vercel, Railway, Render or wherever your app already lives, which means your host's timeouts and bills still apply per step. Inngest's docs note that on Vercel with Fluid compute, streaming can reach a maximum duration of 800 seconds on a paid plan. If you run containers, connect() opens an outbound WebSocket from your workers instead of exposing an endpoint.

Our read: Trigger.dev is the better fit when a single unit of work is long or resource-hungry (FFmpeg, headless browsers, big LLM chains), because it moves that work off your web host entirely. Inngest is the better fit when your workflows are many short steps glued together with sleeps, events and retries, because the steps stay in your codebase, deploy with your app and run on compute you already pay for. If you are still choosing a host, our Railway vs Render comparison covers the always-on option where long Inngest steps are less of a worry.

What the code looks like#

These are simplified shapes to show the mental model, not copy-paste code. Check each SDK's current docs for exact signatures.

Trigger.dev: define a task, then trigger it from your app.

// trigger/process-upload.ts
import { task, wait } from "@trigger.dev/sdk";

export const processUpload = task({
  id: "process-upload",
  run: async (payload: { fileId: string }) => {
    const file = await downloadFile(payload.fileId);
    await transcode(file);          // runs on Trigger.dev's container
    await wait.for({ hours: 1 });   // checkpointed, not billed as compute
    await notifyUser(payload.fileId);
  },
});

// in your API route
await tasks.trigger("process-upload", { fileId });

Inngest: define a function with steps, serve it from your app, then send an event.

// inngest/onboarding.ts
export const onboarding = inngest.createFunction(
  { id: "onboarding" },
  { event: "user/signed.up" },
  async ({ event, step }) => {
    await step.run("send-welcome", () => sendWelcome(event.data.email));
    await step.sleep("wait-a-day", "1d");
    await step.run("send-tips", () => sendTips(event.data.email));
  }
);

// in your API route
await inngest.send({ name: "user/signed.up", data: { email } });

Notice the difference in billing shape: the Inngest function above is one run plus three steps, which Inngest meters as executions, while the Trigger.dev task is one run plus the seconds it spends computing.

Pricing compared#

Trigger.dev#

Usage is billed as $0.000025 per run ($0.25 per 10,000 runs) plus compute per second. A few machine sizes: Micro (0.25 vCPU, 0.25 GB) is $0.0000169/sec, Small 1x (0.5 vCPU, 0.5 GB, the default) is $0.0000338/sec, Medium 1x (1 vCPU, 2 GB) is $0.0000850/sec and Large 1x (4 vCPU, 8 GB) is $0.0003400/sec. Runs in the DEV environment are not charged, and the Free plan needs no credit card. On Free, once the $5 is used you must upgrade to keep running tasks (Trigger.dev pricing).

Inngest#

Inngest defines an execution as "A single durable function run or step execution", and its calculator uses runs × (steps + 1). Free also includes 5 seats and 500k events ingested; Pro includes 15 seats (Inngest pricing). Remember that Inngest's price does not include the compute your functions use on your own host.

Worked cost example: 100,000 runs a month#

Example, not a quote. Assume an indie SaaS runs 100,000 background jobs a month. Each job has 3 steps (fetch, process, notify). We price two cases on published rates.

Case A: short jobs, 2 seconds of compute each.

• Trigger.dev on Small 1x: runs 100,000 × $0.000025 = $2.50. Compute 100,000 × 2 s × $0.0000338 = $6.76. Usage total $9.26, inside Hobby's $10 included credit, so about $10/mo.
• Inngest: 100,000 × (3 + 1) = 400,000 executions. That exceeds Free's 50k, so Pro at $99/mo with 1m included. Your host's function costs come on top.

Case B: heavier jobs, 10 seconds of compute each.

• Trigger.dev on Small 1x: $2.50 for runs plus 100,000 × 10 s × $0.0000338 = $33.80 compute, $36.30 in total. That fits inside Pro's $50 included credit, so about $50/mo. (We did not verify how usage above Hobby's $10 credit is billed, so check before choosing Hobby here.)
• Inngest: still 400,000 executions, so still $99/mo on Pro, because Inngest does not meter duration. But those 10 seconds now run on your host, which you pay for separately.

Our read: Trigger.dev's bill tracks how much work you do; Inngest's tracks how many steps you take. Long, few-step jobs favour Inngest's metering only if your host makes that compute cheap; many short jobs favour Trigger.dev. At very small scale both are free: Trigger.dev's $5 credit covers roughly 54,000 two-second Small 1x runs in this example's arithmetic, and Inngest's 50k executions cover 12,500 runs of 3 steps.

Decision table by situation#

This is our editorial advice, based on the facts above.

On that last row, our guide to adding human approval to AI agents shows the pattern, which maps onto Trigger.dev waits or Inngest steps.

Vendor lock-in#

Both use their own SDK primitives (task and wait vs createFunction and step), so moving between them means rewriting job definitions, not just changing a URL. Self-hosting is the escape hatch for each. Trigger.dev self-hosts on Docker Compose or Kubernetes, but its own page says "Checkpoints (non-blocking waits), warm starts, and auto-scaling are Cloud-only" (Trigger.dev vs Inngest). Inngest says it "is open-source and can be self-hosted" (Inngest pricing), with the server under the SSPL and delayed Apache 2.0 publication (Inngest on GitHub).

Our read: for a solo founder, lock-in is a minor risk compared with shipping. Keep your business logic in plain functions and call them from tasks or steps, so the job layer stays thin.

Other options#

• Vercel Cron Jobs. Included on all plans, 100 per project. Hobby allows one run per day with per-hour precision; Pro allows once per minute. Crons invoke normal Vercel Functions, so function limits apply (Vercel docs). Fine for a nightly cleanup, no retries or steps.
• Upstash QStash. HTTP message queue with a free plan of 1,000 messages per day and pay-as-you-go at $1 per 100K messages (Upstash pricing). Good for simple delayed or retried webhooks.
• Cloudflare Workflows. Durable steps on Workers, included on the Free and Paid plans. Workers Paid includes 10 million requests and 500,000 steps a month, then $0.80 per additional 100,000 steps (Cloudflare docs). A strong fit if you already host on Cloudflare; see our Vercel vs Cloudflare Pages comparison.
• BullMQ. MIT-licensed queue library, described as "based on Redis or PostgreSQL" (BullMQ on GitHub). Cheapest at scale if you are happy to run workers and Redis yourself, with no hosted dashboard included.

Frequently asked questions#

Is Trigger.dev or Inngest cheaper for a small app?#

It depends on how long your jobs run and how many steps they have. Trigger.dev bills $0.25 per 10,000 runs plus compute per second (Small 1x is $0.0000338/sec), with $5 of free credit a month. Inngest bills per execution, where each run and each step counts, with 50k free a month and Pro from $99/mo. In our worked example, 100,000 short runs a month fit inside Trigger.dev Hobby's $10 credit, while the same runs with 3 steps need Inngest Pro.

Does Inngest run my code on its servers?#

No. With serve(), Inngest calls an HTTP endpoint in your app, usually /api/inngest, so your code runs wherever your app is hosted and your host's own limits and bills apply. With connect(), your workers open an outbound WebSocket to Inngest instead. Trigger.dev is different: your tasks run on its managed compute.

Can I self-host Trigger.dev or Inngest?#

Both can be self-hosted. Trigger.dev is Apache 2.0 and self-hosts with Docker Compose or Kubernetes, though its comparison page says checkpoints, warm starts and auto-scaling are Cloud-only. The Inngest server and CLI are under the Server Side Public License with delayed Apache 2.0 publication, and Inngest says self-hosting is possible.

Which works better on Vercel?#

Both work with Next.js on Vercel. Inngest functions run inside your Vercel functions, and Inngest's docs say streaming on Vercel with Fluid compute can reach a maximum duration of 800 seconds on a paid plan. Trigger.dev runs tasks off Vercel on its own containers, and its pricing FAQ says runs have no maximum duration, so long jobs are not bound by Vercel's function limits.

Do I need either if I just want a nightly cron?#

Probably not. Vercel Cron Jobs are included on all plans, although Hobby is limited to one run per day with per-hour precision. If the job is short and failure is cheap, a platform cron is enough. Reach for Trigger.dev or Inngest when you need retries, steps, waits, queues or runs longer than your host allows.

Ship it, then launch it#

Background jobs are plumbing; customers never see them until they break. Pick one, wire up your first retrying job this week, and get back to the product. When it is ready, run through our guide to launching a bootstrapped app, then submit your product to ZeroRaised for free. For more dev tool comparisons for founders building without investors, join the ZeroRaised newsletter.

Sources#

• Trigger.dev pricing, last checked 13 Nov 2026
• Trigger.dev vs Inngest (Trigger.dev's own comparison page), last checked 13 Nov 2026
• Trigger.dev wait documentation, last checked 13 Nov 2026
• Trigger.dev on GitHub, last checked 13 Nov 2026
• Inngest pricing, last checked 13 Nov 2026
• Inngest: serving Inngest functions, last checked 13 Nov 2026
• Inngest local development, last checked 13 Nov 2026
• Inngest on GitHub, last checked 13 Nov 2026
• Vercel Cron Jobs usage and pricing, last checked 13 Nov 2026
• Upstash QStash pricing, last checked 13 Nov 2026
• Cloudflare Workflows pricing, last checked 13 Nov 2026
• BullMQ on GitHub, last checked 13 Nov 2026