Best Background Jobs of 2026

Temporal Cloud is the durable-execution pick for teams running long-running workflows that need to survive process restarts, deployments, and infrastructure failures. Founded in 2019 by ex-Uber Cadence engineers, Temporal built the canonical durable-execution platform where workflow state persists across compute failures and steps replay deterministically from event history.

Three tiers serve three buyers. Free trial ships $1,000 in credits with 14-day evaluation and all features unlocked. Pay-as-you-go ships $0.42 per 1M actions plus $0.039 per GB-day storage with 5 SDKs across Go, Java, Python, TypeScript, .NET. Enterprise ships custom pricing with custom regions plus dedicated cells, premium support, and dedicated CSM.

The load-bearing wedge is durable-execution semantics plus polyglot SDKs. Where Inngest Step Functions retry steps independently and Trigger.dev focuses on TypeScript-first runs, Temporal stores complete workflow history and replays from any point on failure; for long-running workflows (multi-day approvals, multi-week ETL pipelines, distributed sagas), Temporal's history replay handles partial failure differently from event-driven retries. The catch is the conceptual learning curve. For teams running long-running workflows across polyglot services, Temporal is the proven path; for short-lived background jobs, alternatives cost less and learn faster.

Upstash QStash is the HTTP-based serverless pick for teams running on Vercel, Cloudflare Workers, or AWS Lambda where the application stack is already serverless. Built by Upstash founded 2020, QStash treats every job as an HTTP webhook that fires at a scheduled time or after a delay, which fits naturally into serverless functions without long-running worker processes.

Four tiers serve four buyers. Free ships 500 messages per day with no card required, 7-day retention, and HTTP-based delivery. Pay-as-you-go ships $1 per 100K messages with 14-day retention and no max throughput. Pro ships $10/mo plus usage with higher rate limits and 30-day retention. Enterprise ships custom with BYOC option, SAML SSO, and dedicated CSM.

The load-bearing wedge is HTTP-as-job-protocol. Where Inngest, Trigger.dev, Defer, and Hatchet require running worker processes, QStash fires HTTP webhooks at scheduled times; for serverless apps where every endpoint is already an HTTP function, QStash adds nothing new beyond a webhook trigger plus retry. The catch is the lack of step orchestration; multi-step workflows require chaining HTTP calls manually rather than using a Step Functions abstraction. For serverless teams running simple delayed or scheduled tasks, QStash is the proven path; for multi-step workflows, alternatives cover better.

Defer is the simple-TypeScript pick for solo developers and small teams who want a minimal background-jobs SDK without Step Functions complexity. Founded in 2022 in France, Defer built a TypeScript-only SDK that treats each background job as a single function call with optional cron and retry decorators rather than the multi-step durable-execution model of Inngest or Temporal.

Four tiers serve four buyers. Free ships up to 1K executions monthly with TypeScript SDK and 1 environment. Pro ships $15/mo with 10K executions plus multiple environments, cron jobs, and retries. Business ships $99/mo with 100K executions plus higher concurrency and dedicated workers. Enterprise ships custom with BYOC option and SAML SSO.

The load-bearing wedge is API simplicity. Where Inngest ships Step Functions abstraction and Temporal ships durable-execution semantics, Defer ships a single decorator that turns any TypeScript function into a background job; for solo developers building Next.js apps where async work is bounded to single-step tasks, Defer's API is the easiest learn in lineup. The catch is the limited feature surface; no Step Functions, no polyglot SDKs, no durable execution. For solo TypeScript developers building Next.js apps with simple async needs, Defer is the proven entry; for multi-step workflows, alternatives cover better.

Inngest is the default event-driven background-jobs platform for modern TypeScript and Python teams in 2026. Founded in 2021, Inngest built around the Step Functions abstraction where async workflows are defined as durable steps that survive function restarts and retry on failure with per-step idempotency.

Four tiers serve four buyers. Free ships 50K events plus 5K function invocations per day with Step Functions and retries. Basic ships $30/mo with 250K events and 50K invocations per day plus concurrency limits. Pro ships $300/mo with 5M events plus higher concurrency and custom retention. Enterprise ships custom with BYOC option, SAML SSO, audit, and dedicated CSM.

The load-bearing wedge is Step Functions plus event-driven model. Where Trigger.dev and Defer treat each background job as a single function invocation, Inngest treats workflows as multi-step durable executions where each step is independently retryable; for SaaS apps with multi-step user-flows (signup with email plus billing plus provisioning), Inngest's step model handles partial failure naturally. The catch is the per-event pricing compounding past 5M events; Pro $300 covers 5M events but the next tier jumps to Enterprise. For modern SaaS teams running multi-step async workflows, Inngest is the proven path; for simple task queues, alternatives cost less.

Hatchet is the OSS-PostgreSQL pick for engineering teams who want a self-hostable background-jobs platform without Redis dependency. Founded in 2023, Hatchet built the platform around PostgreSQL as the queue backend rather than Redis, which eliminates the operational complexity of running a separate Redis cluster and lets teams reuse their existing PostgreSQL infrastructure.

Four tiers serve four buyers. OSS ships MIT-licensed self-hosted with PostgreSQL plus Go-based core and TypeScript plus Python SDKs. Cloud Free ships up to 10K events monthly with 5 concurrent workers hosted. Cloud Pro ships $50/mo with 250K events plus higher concurrency and SLA. Enterprise ships custom with BYOC plus dedicated infrastructure, SAML SSO, audit, and premium support.

The load-bearing wedge is the PostgreSQL-as-queue model plus permissive MIT license. Where BullMQ requires Redis and SaaS alternatives lock data in vendor cloud, Hatchet runs entirely on customer PostgreSQL with the same Postgres engineers already operate; for teams with PostgreSQL expertise but no Redis ops, Hatchet OSS removes a vendor dependency. The catch is the relative newness of the platform versus Inngest or Temporal. For OSS-purist engineering teams already on PostgreSQL, Hatchet is the proven path; for established platforms with longer track records, alternatives cover better.

Trigger.dev is the TypeScript-first indie-friendly pick for solo developers and small teams who want background jobs without enterprise pricing. Founded in 2022 in the UK, Trigger.dev built around a TypeScript-first SDK with the cheapest paid entry tier in lineup at $10/mo Hobby that targets indie hackers and solo builders.

Four tiers serve four buyers. Free ships 10K runs per month with 1 dev environment and up to 25 concurrent runs. Hobby ships $10/mo with 50K runs and 50 concurrent runs plus standard support. Pro ships $50/mo with 500K runs and 250 concurrent runs plus priority support. Enterprise ships custom with self-hosted option, SAML SSO, and dedicated CSM.

The load-bearing wedge is the indie-friendly $10/mo Hobby tier. Where Inngest Basic starts at $30/mo and other picks jump to enterprise pricing quickly, Trigger.dev Hobby covers indie projects at a third the price; for solo developers running side projects with bounded run counts, the math works without burning the project budget on infrastructure. The catch is the TypeScript-only SDK; Python or Go services cannot use Trigger.dev directly. For solo TypeScript developers running indie projects, Trigger.dev is the proven path; for polyglot teams, alternatives cover better.

BullMQ Pro is the Redis-based pick for teams already running Redis who want job grouping plus observability on top of the BullMQ open-source library. Built by Taskforce.sh founded 2018, BullMQ ships as the canonical Node.js queue library that works on existing Redis infrastructure; BullMQ Pro adds job grouping, observability, and a dashboard at $249/mo per instance.

Three tiers serve three buyers. OSS BullMQ ships MIT-licensed free with Redis-based queue and Node.js library plus community support. Pro ships $249/mo per instance with job grouping, observability, premium support, and dashboard included. Enterprise ships custom pricing with multiple instances, custom support, and dedicated CSM.

The load-bearing wedge is the Redis-already-installed compatibility. Where Hatchet requires PostgreSQL and Inngest is SaaS-only, BullMQ runs on the Redis cluster teams have already deployed for caching or session storage; for teams who already operate Redis, BullMQ adds nothing new to the operational footprint. The catch is the per-instance pricing; $249/mo per Redis instance compounds for teams running multiple Redis clusters. For Node.js teams already on Redis with bounded instance counts, BullMQ Pro is the proven path; for greenfield deployments, alternatives without Redis dependency cover better.