Best Background Job Tools for Indie Hackers in 2026 (Free and Self-Hosted Picks)

Every indie hacker hits this wall. You need to send a welcome email after signup, resize an upload, sync something to Stripe, or run a nightly cleanup. You can't do it inside the request, because the user is sitting there waiting. So it goes in the background. And the moment it does, you have a new problem: what happens when it fails?

That's the whole category in one question. When a task fails halfway through, or your server restarts mid-run, or an external API times out, does the work get retried, or does it silently vanish? Building the answer yourself means a queue, a worker process, retry logic, dead-letter handling, and a dashboard to see what broke. That's a lot of plumbing for one person.

The good news: you have real options, most with generous free tiers. If your data already runs through Inngest, event fan-out is handled for you. Trigger.dev is open source and free to self-host. QStash is the cheapest way to run async work on serverless. And if you build in Laravel, you already have one of the best tools installed.

Five below, with honest notes on where each one is the wrong call.

What makes a good background job tool?

Strip away the marketing and it comes down to four things. Durability: if the process dies, the job survives and resumes. Retries: a failed step tries again with backoff instead of disappearing. Scheduling: you can run work on a cron, after a delay, or in response to an event. And observability: when something breaks at 3am, you can see which job, which step, and why. Everything below is judged on how well it does those four for a small team, and how much of your own infrastructure it makes you run to get them.

Quick verdict

Inngest: durable functions with no infrastructure

Inngest is the best managed pick for most people, because it removes the most plumbing. You write a function made of steps, and each step is individually durable: if step 3 fails after steps 1 and 2 succeeded, Inngest retries only step 3 without re-running the whole thing. Steps can sleep for minutes, hours, or days, which makes multi-day onboarding sequences and trial-expiry reminders trivial. There's no Redis and no worker to run; the orchestration is hosted.

Its real strength is the event-driven model. One user action can fan out to four or ten side effects, each with its own retries and visibility. The TypeScript, Python, and Go SDKs deploy alongside your app on Vercel, Cloudflare Workers, or any Node backend, and the local dev server is one of the better developer experiences in this category.

The free Hobby tier includes 50,000 runs a month, which covers a real beta. Pro is $75 a month for a million executions. One billing subtlety worth knowing: an execution is the run plus each step, so a five-step function uses six executions, not one. Budget against your step count, not just your run count.

Who should not use Inngest: anyone who needs the cheapest option at high volume, since per-execution pricing grows linearly while a self-hosted queue stays flat. The free tier caps concurrency at 5 steps, which constrains heavy fan-out until you upgrade, and the jump from Hobby to Pro is a real step up. Every piece of logic has to be wrapped in explicit step.run() calls, which is more verbose than a plain async function. It is open source and self-hostable, but the cloud is clearly the intended path.

Trigger.dev: open source and built for long tasks

Trigger.dev is the pick when you want to own the thing. It's Apache 2.0 licensed with genuine, first-class self-hosting, so you can run it on your own server with no per-run fees and no artificial limits. That license matters if data residency is a requirement or you just don't want another vendor holding your workflow logic.

The model is task-driven rather than event-driven: you trigger a task by name, and it runs as a single durable run with retries and observability. It shines on long-running single tasks, a 90-second image generation, a multi-step LLM agent, a multi-hour export, partly because it runs tasks in isolated containers with selectable machine sizes. Its wait functions snapshot the process and restore it later, so you don't pay for time spent idle during a multi-day flow.

On cloud pricing, there's a free tier for evaluation, a $10 a month Hobby plan for small production use, and a $50 a month Pro plan. Cloud billing is usage-based on execution time, run count, and machine size, so model your average run duration before committing. Self-hosting sidesteps all of that.

Who should not use Trigger.dev: teams that want zero operational surface and never plan to self-host, who may find Inngest's hosted-only simplicity cleaner. The usage-based cloud pricing is genuinely easy to mis-estimate if your tasks run long or you default every job to a bigger machine. And self-hosting, while real, means you now run and upgrade the platform, its database, and its Redis yourself.

Upstash QStash: the simplest serverless option

QStash solves a specific problem: serverless platforms like Vercel, Cloudflare Workers, and Netlify can't run background processes, so you need something external to hold and deliver the work. QStash is an HTTP-based message queue. You POST a message with a destination URL, and it delivers reliably with automatic retries, a dead-letter queue, delayed delivery, and cron scheduling. No SDK, no long-lived connection, no infrastructure.

For simple async work this is the least effort of anything here. Fire a webhook, queue an email, schedule a one-off job, and move on. Because it's pure HTTP, it works from any language.

Pricing is genuinely cheap at small scale: the free tier covers 500 messages a day, and pay-as-you-go is $1 per 100,000 messages, with 1,000 active schedules free. Fixed plans start at $180 a month for higher throughput.

Who should not use QStash: anyone building complex, multi-step, stateful workflows. It's a delivery pipe, not a durable-execution engine, so orchestration with branching and fan-out belongs on Inngest or Trigger.dev instead. Note the billing counts each delivery attempt as a message, so a job that retries three times bills as three. And if you're not on serverless, a normal queue is often a better fit than routing everything over HTTP.

BullMQ: full control, lowest cost at scale

BullMQ is the do-it-yourself option, and for a certain kind of developer it's the right one. It's an MIT-licensed Node library built on Redis, with no per-run pricing at all. You get queues, retries, rate limiting, delayed jobs, and repeatable jobs, and you wire them into your own worker processes. At scale this is the cheapest path by a wide margin, because your cost is just Redis and compute rather than a per-job meter.

The trade is that you own everything. Redis hosting runs $5 to $10 a month for small workloads on Upstash or Redis Cloud, more for a dedicated instance, and you build your own observability or pay $1,395 a year for BullMQ Pro's advanced features and dashboard.

Who should not use BullMQ: solo founders who want to ship, not operate. You're responsible for running Redis, keeping workers alive, handling deployment, and building the monitoring that Inngest and Trigger.dev give you out of the box. It's Node-only, and getting durability and dead-letter handling genuinely right takes more care than the happy-path demo suggests. Pick it when control and unit cost matter more than your time.

Laravel Queues and Horizon: already in your framework

If you build in Laravel, you can likely skip this whole comparison, and that's worth saying plainly rather than burying. Laravel ships a full queue system built in, with drivers for database, Redis, Amazon SQS, and Beanstalkd, plus retries, delays, rate limiting, batching, and unique jobs. Horizon is the free first-party dashboard for Redis-backed queues: real-time metrics, throughput, failed-job retries, and tag-based monitoring. Together they cover what most solo SaaS apps need, and they cost nothing.

The catch is where it runs. Queues and Horizon are free, but you need somewhere to keep a worker process alive, whether that's a $5 VPS running Supervisor, your existing app server, or a managed host. That's the "no infrastructure" convenience you'd be paying Inngest for.

Who should not lean on Horizon: teams not on Laravel, obviously, and Laravel apps deployed somewhere with no persistent process to run a worker, like a purely serverless setup, where QStash fits better. Horizon is also Redis-only, so a database-driven queue doesn't get the dashboard. For most Laravel founders on a normal VPS, though, this is the honest answer: you already have it, so use it before you buy anything.

When you outgrow all of these

One tool sits deliberately outside the main list. Temporal is the heavyweight durable-execution engine that large teams reach for when workflows get genuinely complex and mission-critical. It's open source and self-hostable, with SDKs in seven languages, but Temporal Cloud starts around $100 a month and the operational model is heavier than anything above. For a solo founder it's usually overkill. Worth knowing it exists, and worth knowing about its startup program, which offers $6,000 in Cloud credits to startups under $30 million in funding, but reach for it when you've outgrown the simpler options, not before.

How do you choose?

Match the tool to your stack and your appetite for running infrastructure.

• You build in Laravel: Laravel Queues and Horizon. Free, built in, already there.
• You want managed with no Redis and event fan-out: Inngest. The least plumbing for complex workflows.
• You want open source you can self-host, or run long tasks: Trigger.dev.
• You're on serverless and need simple async: QStash. Dead simple, dead cheap at small scale.
• You want full control and the lowest cost at scale: BullMQ, if you're happy running Redis.

flowchart TD
    A[Need to run background work?] --> B{Building in Laravel?}
    B -- yes --> C[Laravel Queues and Horizon]
    B -- no --> D{On serverless with simple async needs?}
    D -- yes --> E[Upstash QStash]
    D -- no --> F{Want to run your own infrastructure?}
    F -- yes --> G[BullMQ on Redis]
    F -- no --> H{Need open source or self-host option?}
    H -- yes --> I[Trigger.dev]
    H -- no --> J[Inngest]

The verdict

For a Laravel founder, the answer is almost always Laravel Queues and Horizon. They're free, they're already installed, and they do what most SaaS apps need. Don't pay for a background job service until you've genuinely outgrown them.

If you're not on Laravel, it comes down to how much infrastructure you want to run. Inngest is the best managed pick because it removes the most work: durable steps, event fan-out, retries, and a dashboard, with no Redis and a free tier that covers a real beta. Trigger.dev is the one to choose if open source and self-hosting matter, or if your jobs are long-running single tasks. QStash is the right small tool for simple async on serverless. And BullMQ is the pick when you want full control and the lowest possible cost at scale, and you're comfortable running Redis to get it.

The pattern underneath is the familiar one: the managed tools trade money for time, the self-hosted ones trade time for money, and the framework-native option gives you most of it for free if you're already in the right ecosystem. Start with what your stack already offers, and pay for a service only when the plumbing becomes the thing you're spending your evenings on.

Wherever these jobs run, you'll want to know when they fail, so our Sentry alternatives guide covers error alerting, and for the servers the workers run on, Railway vs Render vs Fly.io and Laravel Forge vs Ploi vs Coolify both fit the same solo-SaaS stack.