Inngest vs Trigger.dev vs Temporal

Background Jobs Are Infrastructure Now

Every production application eventually needs to run work outside the request/response cycle: send emails after a delay, process uploaded files, orchestrate multi-step onboarding sequences, retry failed API calls with backoff, fan out work across hundreds of tasks in parallel.

The naive approach — cron jobs, raw queues, custom retry logic — breaks at scale. Lost jobs, zombie workers, no visibility into failures, and state management nightmares are the predictable result.

In 2026, three platforms define the modern approach to background job orchestration: Inngest (serverless durable workflows with an event-driven model), Trigger.dev (open-source AI agent and workflow platform with self-hosting), and Temporal (enterprise-grade durable workflow engine powering some of the largest distributed systems in the world).

TL;DR

Inngest is the best choice for Next.js and serverless teams — 100K free executions/month, native Vercel/Cloudflare integration, and step functions that survive failures without managing queue infrastructure. Trigger.dev wins for teams that need open-source transparency or self-hosting, with a v3 platform increasingly focused on AI agent orchestration. Temporal is the choice when you need enterprise-grade workflow durability at massive scale — it powers Netflix, Stripe, and Uber's distributed workflows, but the learning curve and $100/month minimum are real commitments.

Key Takeaways

• Inngest offers 100K free executions/month — the most generous free tier of the three for getting started without infrastructure management.
• Inngest step functions are durable by design — each step saves its result independently, so failures restart only the failed step, not the entire workflow.
• Trigger.dev is fully open-source (Apache 2.0) — self-host with unlimited runs, no licensing fees, and deploy in your own infrastructure.
• Trigger.dev v3 focuses on AI agent workflows — built-in support for long-running AI tasks, streaming, and agent orchestration patterns.
• Temporal Cloud starts at $100/month — pricing by Actions (workflow operations) with consumption-based overage; expensive for small teams, right for enterprise scale.
• Temporal's self-hosted version is free — the open-source Temporal server is production-ready and powers many large-scale deployments at infrastructure cost only.
• All three handle retries, concurrency, and observability — the difference is in the execution model, SDK ergonomics, and operational complexity.

The Core Problem Each Solves

Before comparing, understand the fundamental problem: distributed workflows fail in unpredictable ways.

Your email-after-signup flow has three steps: create the account, send a welcome email, enqueue a 7-day follow-up. If step 2 succeeds but step 3 fails due to a timeout, what happens? Without durability guarantees, you have a user with an account, a welcome email sent, but no follow-up queued — and no record of the inconsistency.

Durable workflow orchestration solves this by persisting state between steps, enabling reliable retries at the step level, and providing full visibility into workflow execution history.

Inngest

Best for: Serverless teams, Next.js applications, event-driven workflows, getting started fast

Inngest wraps your existing serverless functions with durability and orchestration — no separate workers to run, no queue infrastructure to manage. Deploy your Inngest functions alongside your Next.js app and Inngest handles the rest.

Pricing

Plan	Executions	Cost	Step Runs	Concurrency
Hobby	100K/month	Free	Included	5
Pro	Unlimited	$75/month + usage	$0.40/1K after included	Higher
Enterprise	Custom	Custom	Custom	Custom

Additional executions on Pro: $0.40 per 1,000 runs after the plan's included volume.

The Hobby plan's 100K executions covers most small-to-medium applications. A multi-step workflow counts each step as a separate execution — a 5-step onboarding flow counts as 5 executions per signup.

Step Functions — The Core Feature

Inngest's step model is the key differentiator for serverless workflows:

import { inngest } from "./inngest-client";

export const onboardUser = inngest.createFunction(
  { id: "onboard-user" },
  { event: "user/signed-up" },
  async ({ event, step }) => {
    // Step 1: Create workspace — saved, retried independently if it fails
    const workspace = await step.run("create-workspace", async () => {
      return await db.workspace.create({ userId: event.data.userId });
    });

    // Step 2: Send welcome email — runs only after step 1 succeeds
    await step.run("send-welcome-email", async () => {
      await email.send({
        to: event.data.email,
        template: "welcome",
        data: { workspaceId: workspace.id },
      });
    });

    // Step 3: Wait 3 days, then send follow-up (survives restarts)
    await step.sleep("wait-for-followup", "3 days");

    await step.run("send-followup-email", async () => {
      await email.send({ to: event.data.email, template: "day-3-followup" });
    });
  }
);

If the "send-welcome-email" step fails after 3 retries, Inngest records the failure, surfaces it in the dashboard, and doesn't retry "create-workspace" — it picks up from exactly where it left off.

Event-Driven Architecture

Everything in Inngest is triggered by events, creating a clean audit trail:

// Trigger workflows from your API handlers
await inngest.send({
  name: "user/signed-up",
  data: { userId: "user_123", email: "user@example.com", plan: "pro" },
});

// Multiple functions can respond to the same event
// This creates fan-out naturally

Vercel and Next.js Integration

Inngest is a first-class Vercel marketplace integration — add it in one click and your functions deploy as Vercel serverless functions with Inngest coordination. No separate infrastructure.

// app/api/inngest/route.ts — single API route for all Inngest functions
import { serve } from "inngest/next";
import { inngest } from "@/inngest/client";
import { onboardUser, sendWeeklyDigest } from "@/inngest/functions";

export const { GET, POST, PUT } = serve({ client: inngest, functions: [onboardUser, sendWeeklyDigest] });

When to Choose Inngest

Next.js and Vercel teams, serverless-native applications, teams that want orchestration without managing queue infrastructure, event-driven architectures, applications with long-running workflows that span days (using step.sleep).

Trigger.dev

Best for: Open-source requirements, self-hosting, AI agent workflows, teams on a budget

Trigger.dev v3 repositioned itself in 2025 from a general background job platform to an AI agent and workflow orchestration platform. The open-source core (Apache 2.0) and self-hosting option make it unique among the three — enterprise teams with data sovereignty requirements can run Trigger.dev on their own infrastructure with unlimited runs.

Pricing

Plan	Runs	Cost	Concurrency	Self-Host
Free	5K/month	$0	Included	Yes
Hobby	More	Low	Increased	Yes
Pro	Unlimited	~$20+/month	Higher	Yes
Bring Your Own Cloud	Unlimited	AWS/GCP/Azure costs	Custom	Managed on your infra
Enterprise	Custom	Custom	Custom	Full support

The open-source self-hosted option has no licensing fee — you pay only for the infrastructure you run. Trigger.dev's "Bring Your Own Cloud" option is a managed deployment in your AWS, GCP, or Azure account, giving you the managed service experience with your own data boundaries.

AI Agent Workflows — v3 Focus

Trigger.dev v3's primary differentiation is AI agent orchestration:

import { task, wait, logger } from "@trigger.dev/sdk/v3";

export const researchAgent = task({
  id: "research-agent",
  run: async (payload: { query: string }) => {
    logger.info("Starting research", { query: payload.query });

    // Long-running AI tasks — no timeout anxiety
    const outline = await generateOutline(payload.query);

    // Fan out research to parallel tasks
    const sections = await Promise.all(
      outline.sections.map((section) =>
        researchSection.triggerAndWait({ section, depth: "comprehensive" })
      )
    );

    // Assemble final document
    const report = await assembleReport({ outline, sections });

    return { report, sectionsResearched: sections.length };
  },
});

export const researchSection = task({
  id: "research-section",
  // Long timeouts for AI tasks
  machine: { preset: "large-1x" },
  run: async (payload: { section: string; depth: string }) => {
    // Each section researched independently, retriable
    return await deepResearch(payload.section, payload.depth);
  },
});

Self-Hosting Architecture

# docker-compose for self-hosted Trigger.dev
version: "3.8"
services:
  trigger:
    image: ghcr.io/triggerdotdev/trigger.dev:latest
    environment:
      DATABASE_URL: postgresql://postgres:password@db:5432/trigger
      REDIS_URL: redis://redis:6379
      SECRET_KEY: your-secret-key
    ports:
      - "3030:3030"
  db:
    image: postgres:15
  redis:
    image: redis:7

Self-hosted Trigger.dev gives you full workflow history, real-time logs, retries, concurrency controls, and the dashboard — all running in your own infrastructure.

When to Choose Trigger.dev

Teams requiring open-source transparency, organizations with data residency requirements, AI agent applications needing long-running task orchestration, teams on tight budgets (self-hosting is free), or teams already invested in the open-source ecosystem.

Temporal

Best for: Enterprise scale, complex long-running workflows, regulated industries, highest durability guarantees

Temporal is the enterprise choice for workflow orchestration. Originally developed at Uber as Cadence, Temporal powers distributed workflows at Netflix, Stripe, Coinbase, DoorDash, and Snap. It's the most mature and battle-tested workflow engine available, but it comes with a steeper learning curve and significantly higher minimum cost than Inngest or Trigger.dev.

Pricing

Deployment	Cost	Actions
Self-hosted	Infrastructure only	Unlimited
Temporal Cloud Essentials	$100/month minimum	5M Actions included
Temporal Cloud Professional	$200/month minimum	Custom
Enterprise	Custom	Custom

Actions are Temporal's billing unit — every workflow operation counts: starting a workflow, scheduling an activity, recording a heartbeat, completing a workflow. A simple 3-step workflow generates ~6-10 Actions.

For 50M actions/month, realistic Temporal Cloud costs are $2,000-$3,000/month — significantly more than Inngest or Trigger.dev, but justified for teams that need Temporal's guarantees.

The Temporal Programming Model

Temporal's model is different from Inngest and Trigger.dev — workflows are code, and Temporal makes that code resilient:

// Temporal workflow in Go
func OnboardingWorkflow(ctx workflow.Context, input OnboardingInput) error {
    options := workflow.ActivityOptions{
        StartToCloseTimeout: time.Minute,
        RetryPolicy: &temporal.RetryPolicy{
            MaximumAttempts: 3,
            BackoffCoefficient: 2.0,
        },
    }
    ctx = workflow.WithActivityOptions(ctx, options)

    // Each activity is durable — Temporal persists state between steps
    var workspace Workspace
    if err := workflow.ExecuteActivity(ctx, CreateWorkspace, input.UserID).Get(ctx, &workspace); err != nil {
        return err
    }

    if err := workflow.ExecuteActivity(ctx, SendWelcomeEmail, input.Email, workspace.ID).Get(ctx, nil); err != nil {
        return err
    }

    // Sleep for 3 days — the workflow is dormant but survives restarts
    workflow.Sleep(ctx, 3*24*time.Hour)

    return workflow.ExecuteActivity(ctx, SendFollowupEmail, input.Email).Get(ctx, nil)
}

Temporal's event sourcing model means every state transition is recorded. Workflows can sleep for years, survive server restarts, and be replayed from history for debugging.

TypeScript SDK

import { proxyActivities } from "@temporalio/workflow";
import type * as activities from "./activities";

const { createWorkspace, sendWelcomeEmail, sendFollowupEmail } = proxyActivities<typeof activities>({
  startToCloseTimeout: "1 minute",
});

export async function onboardUser(input: { userId: string; email: string }) {
  const workspace = await createWorkspace(input.userId);
  await sendWelcomeEmail(input.email, workspace.id);

  await sleep("3 days");

  await sendFollowupEmail(input.email);
}

Temporal's Strengths at Scale

• Event sourcing — complete workflow history, replayable for debugging
• Long-running workflows — workflows can run for years (not days)
• Signal and query — send signals to running workflows, query their current state
• Child workflows — hierarchical workflow composition at scale
• Polyglot — Go, Java, TypeScript, Python, .NET, PHP SDKs
• Battle-tested — runs at Uber, Netflix, DoorDash at massive scale

When to Choose Temporal

Enterprise teams with complex long-running business processes, regulated industries requiring full audit trails and workflow history, organizations where the $100/month minimum is not a constraint, teams already running Temporal open-source that need managed hosting, or any application where Inngest or Trigger.dev hit their ceiling.

Head-to-Head Comparison

Feature	Inngest	Trigger.dev	Temporal
Free tier	100K executions/month	5K runs/month	Self-hosted only
Paid starting price	$75/month	~$20/month	$100/month
Open source	SDK only	Full platform (Apache 2.0)	Full platform (MIT)
Self-hosted	No	Yes	Yes
Serverless native	Yes (best-in-class)	Yes	Requires workers
Step-level retries	Yes	Yes	Yes (activities)
Sleep / wait	Yes (step.sleep)	Yes	Yes
AI agent support	Good	Excellent (v3 focus)	Good
Language support	TypeScript	TypeScript	Go, Java, TS, Python, .NET
Vercel integration	Native	Yes	Community
Max sleep duration	Days-weeks	Days-weeks	Years
Workflow history	Limited	Full	Full (event sourced)
Learning curve	Low	Low-medium	High
Enterprise scale	Medium	Medium-high	Highest

Decision Framework

Scenario	Recommended
Next.js / Vercel team	Inngest
Serverless, no infrastructure	Inngest
Open-source required	Trigger.dev
Self-hosting required	Trigger.dev or Temporal
AI agent orchestration	Trigger.dev
Enterprise, 100M+ actions/month	Temporal
Long-running workflows (months-years)	Temporal
Regulated industry, full audit trail	Temporal
Small team, tight budget	Inngest (free) or Trigger.dev (self-host)
Polyglot team (Go, Java, Python)	Temporal

Code Comparison: Fan-Out Pattern

The same fan-out pattern (process 1,000 items in parallel):

Inngest:

export const processItems = inngest.createFunction(
  { id: "process-items", concurrency: { limit: 100 } },
  { event: "items/batch-ready" },
  async ({ event, step }) => {
    await Promise.all(
      event.data.itemIds.map((id) =>
        step.run(`process-${id}`, () => processItem(id))
      )
    );
  }
);

Trigger.dev:

export const processBatch = task({
  id: "process-batch",
  run: async (payload: { itemIds: string[] }) => {
    const results = await batchTriggerAndWait(processItem, payload.itemIds.map((id) => ({ payload: { id } })));
    return results;
  },
});

Temporal:

export async function processBatch(itemIds: string[]) {
  await Promise.all(
    itemIds.map((id) => processItemActivity(id))
  );
}

All three handle fan-out elegantly. The differences are in the operational model — Inngest and Trigger.dev abstract away worker management, while Temporal requires running and scaling worker processes.

Verdict

Inngest is the default recommendation for Next.js and serverless teams in 2026. The native Vercel integration, 100K free executions, and step function model solve 90% of background job use cases without managing any queue infrastructure. Start here unless you have specific requirements that push you elsewhere.

Trigger.dev is the right choice when open-source transparency, self-hosting, or AI agent orchestration is the primary requirement. The v3 platform's focus on long-running AI tasks and the Apache 2.0 license make it uniquely suited for teams building AI applications that need data sovereignty.

Temporal is justified when you're operating at enterprise scale, need workflow history for compliance, or require workflows that run for months to years. The $100/month minimum and operational complexity are real costs — but for teams that need Temporal's guarantees, nothing else provides the same level of durability and observability.

---

Compare background job and workflow orchestration API pricing, documentation, and integration guides at APIScout — find the right orchestration platform for your application.