Inngest Review 2026: Background Jobs Without the Infrastructure

Inngest runs durable functions and background jobs on serverless infrastructure. No queues to manage, no workers to scale. Define functions in your codebase, Inngest handles execution, retries, and orchestration.

What Inngest Does

• Background functions — run long-running tasks outside request/response
• Event-driven — trigger functions from events in your app
• Durable execution — functions survive crashes and retries automatically
• Step functions — break complex workflows into reliable steps
• Cron jobs — scheduled function execution
• Concurrency control — rate limiting and throttling built in

What I Like

Define Functions in Your Codebase

import { inngest } from './client'

export const processOrder = inngest.createFunction(
  { id: 'process-order' },
  { event: 'order/created' },
  async ({ event, step }) => {
    // Step 1: Charge payment
    const payment = await step.run('charge-payment', async () => {
      return await stripe.charges.create({ amount: event.data.total })
    })

    // Step 2: Send confirmation email (runs after step 1)
    await step.run('send-confirmation', async () => {
      await resend.emails.send({
        to: event.data.email,
        subject: 'Order Confirmed',
      })
    })

    // Step 3: Update inventory
    await step.run('update-inventory', async () => {
      await db.update(products).set({ stock: sql`stock - 1` })
    })
  }
)

Each step.run() is independently retried. If step 2 fails, step 1 doesn't re-execute. Durable by default.

Works with Existing Frameworks

// Next.js API route
import { serve } from 'inngest/next'
import { inngest } from './client'
import { processOrder } from './functions'

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

Add Inngest to your existing Next.js, Remix, or Express app. No separate infrastructure.

Event-Driven Architecture

// Send an event from anywhere in your app
await inngest.send({
  name: 'order/created',
  data: { orderId: '123', total: 2999, email: 'user@example.com' },
})

Multiple functions can listen to the same event. Decoupled, scalable architecture.

Built-In Observability

Dashboard shows every function execution: input, output, steps, errors, retry history. Debug production issues by replaying events.

Concurrency and Rate Limiting

export const syncData = inngest.createFunction(
  {
    id: 'sync-data',
    concurrency: { limit: 5 }, // Max 5 concurrent executions
    throttle: { limit: 100, period: '1m' }, // Max 100/minute
  },
  { event: 'data/sync-requested' },
  async ({ event }) => { /* ... */ }
)

No external rate limiting needed. Inngest handles concurrency control.

What I Don't Like

Vendor Lock-In

Your background jobs are tied to Inngest's platform. Migrating means rewriting your job processing infrastructure.

Cold Starts

Functions run on your serverless infrastructure (Vercel, etc.). Cold start latency applies. Not ideal for sub-second response requirements.

Pricing at Scale

Free tier is generous (25K function runs/month). But at millions of runs, costs add up. Self-hosting is an option (Inngest is open source).

Learning Curve

The step function pattern is different from traditional queue-based background jobs. Takes time to think in steps and events.

Pricing

Tier	Price	Includes
Free	$0	25K runs/mo, 5 concurrent
Pro	$25/mo	100K runs, 50 concurrent
Team	$50/mo	500K runs, 100 concurrent
Scale	Custom	Unlimited

Self-hosting: free (open source).

Best Use Cases

• SaaS onboarding flows — multi-step user setup
• Payment processing — charge → email → update DB reliably
• Data pipelines — ETL with automatic retries
• Webhook processing — reliable incoming webhook handling
• Scheduled jobs — cron without cron infrastructure
• AI workflows — chain LLM calls with retries

FAQ

Inngest vs BullMQ/Redis queues?

BullMQ requires Redis and worker processes. Inngest is serverless — no infrastructure. Choose BullMQ for self-hosted, high-volume. Inngest for serverless simplicity.

Can I self-host Inngest?

Yes. Inngest is open source. Self-host for free if you want full control.

Is Inngest production-ready?

Yes. Used by many companies for production background jobs.

Bottom Line

Inngest is the best background job solution for serverless apps in 2026. Step functions with automatic retries, event-driven architecture, and zero infrastructure. The tradeoff is vendor lock-in and cost at scale. For Vercel/serverless developers who need reliable background processing, Inngest is the answer.