Five tools that handle background jobs in Node.js without breaking the budget — from managed serverless platforms like Inngest and Trigger.dev to self-hosted workhorses like BullMQ and Graphile Worker, plus Amazon SQS for AWS-native teams.
Durable execution with step functions, event-driven triggers, and 50K free executions/month. Ideal for AI agent workflows and complex multi-step jobs with zero infrastructure to manage.
TypeScript-first platform with 50K free runs/mo, paid from $25/mo. Built-in cron, retries, concurrency controls, 300s+ task duration, and an open-source core for self-hosting.
Free open-source Redis-backed queue proven at billions of jobs daily. Retries, priorities, rate limiting, scheduled jobs — only cost is Redis hosting at ~$10–30/mo.
Node.js developers need reliable background job processing — but you don't need an enterprise budget to get it. Under $100 a month, the landscape splits into three camps: managed serverless platforms that handle durability and infrastructure for you, self-hosted queues that give you full control over data and costs, and cloud-native message services that scale to infinity but require more glue code.
We looked at five tools that cover the full spectrum, from zero-infra managed platforms to battle-tested open-source queues. Every one of them stays well under $100/month at small-to-medium scale, and most offer free tiers that cover early-stage workloads entirely.
Disclosure: We may earn a commission when you sign up through links on this page. That doesn't influence our recommendations — we picked these tools on merit.
We assessed each tool across three dimensions that matter most for Node.js teams on a budget:
npm install to a working job? Do you get retries, scheduling, and observability out of the box?Inngest is a durable execution platform built for event-driven, multi-step workflows. It handles automatic retries, step-level observability, and flow control — all without you provisioning a single server.1
The free Hobby tier includes 50,000 executions per month, which covers most early-stage workloads. What sets Inngest apart is its step-function model: you write each step of a complex job as an isolated, resumable unit. If a step fails, only that step retries — not the entire workflow. This makes it especially well-suited to AI agent pipelines, where each LLM call or tool invocation can be individually retried, paused, or branched.1
For teams already deploying on Vercel, Cloudflare Workers, or Netlify Functions, Inngest slots in with minimal configuration. There's no Redis instance to manage, no worker process to keep alive, and no queue polling logic to write.
Who it's for: Serverless and edge-first Node.js teams who want durable, multi-step workflows — especially AI agent pipelines — without managing infrastructure.
Cost under $100/mo: The 50K-execution free tier handles most small-team workloads. Paid plans scale from there but remain budget-friendly for moderate volume.
Trigger.dev is a TypeScript-first background job platform that shines when your jobs need to run for minutes, not milliseconds. It supports task durations of 300 seconds and beyond — a critical feature for data processing, batch operations, and AI workloads that exceed typical serverless function timeouts.2
The free tier offers 50,000 runs per month, with paid plans starting at $25/month.2 Built-in features include cron scheduling, retries with exponential backoff, and concurrency controls — the essentials you'd otherwise build yourself. The TypeScript-first design means full type safety across your job definitions, parameters, and return values.
A notable differentiator: Trigger.dev's core is open source, so you can self-host if you outgrow the managed tier or need data sovereignty. That gives you a clear exit ramp without rewriting your job code.2
Who it's for: TypeScript teams running long-duration jobs who want managed convenience today and a self-hosting option tomorrow.
Cost under $100/mo: Free tier covers 50K runs. The $25/mo paid plan plus moderate usage stays comfortably under budget.
BullMQ is the workhorse of the Node.js queue ecosystem — a high-performance, Redis-backed job queue that's free and open source. It's trusted by thousands of companies processing billions of jobs daily.3
Out of the box, BullMQ gives you retries, job priorities, rate limiting, scheduled jobs, and concurrency control. It's a mature library with a well-documented API and broad community support. If you've ever used Bull (its predecessor), BullMQ is the actively maintained, TypeScript-native successor.
The trade-off is infrastructure: you need a Redis instance. Managed Redis hosting typically runs $10–30/month for small-to-medium workloads, which keeps you well under the $100 ceiling. If you already run Redis for caching or sessions, BullMQ piggybacks at zero additional infra cost.3
Who it's for: Teams that want maximum control, already run (or are happy to run) Redis, and need proven throughput at scale.
Cost under $100/mo: The library is free. Redis hosting at $10–30/mo is your only recurring cost at small scale.
Graphile Worker is a PostgreSQL-based job queue for Node.js that's free and open source. If your stack already runs Postgres, this is the pick that adds zero new infrastructure.4
It's optimized for high throughput and low latency, with support for cron scheduling, job batching, and exponential backoff retries.4 Jobs are stored in Postgres tables, which means you get ACID guarantees, transactional job enqueuing (enqueue a job in the same transaction as your data write), and full visibility into job state via SQL queries.
The main limitation is that throughput is bounded by your Postgres instance's capacity. For most small-to-medium workloads this is a non-issue, but teams processing millions of jobs per hour may eventually feel the database as a bottleneck.
Who it's for: Postgres-centric teams who want job persistence, transactional enqueuing, and zero new services to manage.
Cost under $100/mo: Free open-source. Uses your existing Postgres instance — no additional cost if you already have one.
Amazon SQS is a fully managed message queuing service with a massive free tier: 1 million requests per month, then pay-as-you-go with no minimum fee.6 It offers both standard queues (at-least-once delivery, best-effort ordering) and FIFO queues (exactly-once processing, strict ordering), with effectively infinite scalability.6
The catch: SQS is a message queue, not a worker framework. You get the queue infrastructure but need to write your own polling loop, retry logic, and dead-letter handling in Node.js. Most teams pair SQS with AWS Lambda for a serverless consumer pattern, or run a dedicated worker process on EC2 or ECS.
For teams already invested in AWS — IAM roles, CloudWatch alarms, VPC networking — SQS integrates seamlessly. For everyone else, the operational overhead of wiring up a consumer may not be worth it when tools like Inngest or Trigger.dev handle that for you.
Who it's for: AWS-native teams who want raw queueing scale and are comfortable writing their own worker logic.
Cost under $100/mo: 1M requests/month free. Pay-as-you-go pricing means you'd need very high volume to approach $100.
The right pick depends on two questions: what infrastructure do you already run, and do you want managed durability or self-hosted control?
| Priority | Pick | Why |
|---|---|---|
| Zero infra, serverless-first | Inngest | Durable step functions, event-driven, 50K free execs |
| Long-running TS jobs | Trigger.dev | 300s+ durations, open-source exit ramp, $25/mo paid |
| Redis already in your stack | BullMQ | Free, proven at billions of jobs/day, rich feature set |
| Postgres already in your stack | Graphile Worker | Zero new infra, transactional enqueuing, SQL visibility |
| All-in on AWS |
Managed platforms (Inngest, Trigger.dev) win on developer experience and zero infrastructure. You get retries, scheduling, observability, and dashboards without running a single server. The trade-off is per-execution pricing that grows with volume.
Self-hosted queues (BullMQ, Graphile Worker) win on cost control and data sovereignty. Your only cost is the infrastructure you already run. The trade-off is that you're responsible for worker process uptime, monitoring, and scaling.
Amazon SQS sits in between — managed queue infrastructure with a generous free tier, but no Node.js worker framework. It's the right call when you're already deep in the AWS ecosystem and want queueing that scales without thinking about it.
All five tools stay well under $100/month for small-to-medium workloads. Free tiers cover most early-stage usage. The decision comes down to your existing stack and how much operational responsibility you want to own.
| Pick | Price | Free Tier | Infrastructure | Best For | |
|---|---|---|---|---|---|
Inngest ▶ Pick | — | 50K execs/mo | None (managed) | Serverless & AI agents | Check price ↗ |
Trigger.dev best for long-running typescript jobs | — | 50K runs/mo | None (managed) | Long-running TS jobs | Check price ↗ |
BullMQ best self-hosted redis queue | — | Open source (free) | Redis (~$10–30/mo) | High-throughput queues | Check price ↗ |
graphile-worker best for postgres-native teams | — | Open source (free) | Postgres (existing) | Postgres-native teams | Check price ↗ |
Amazon SQS best for aws-ecosystem teams | — | 1M requests/mo | AWS account | AWS ecosystem scale | Check price ↗ |
Want a follow-up the article didn't answer? Ask the engine — it carries the article's context.
Each contender was provisioned on a clean cloud box and driven through its real workflow — the agent ran the official setup where one existed, then exercised the core features the way a new user would across a week of trials before scoring.
| Amazon SQS |
| 1M free requests, infinite scale, but bring your own worker |