BullMQ alternative
Background jobs without Redis or workers.
BullMQ runs your jobs in workers that pull from Redis, so next to your app you run Redis, the workers, and a dashboard to see inside. Workly turns it around. Your job is a route in the app you already deploy, serverless included, and Workly calls it, with retries, timeouts, rate limits and schedules, and keeps every attempt.
What you stop running.
Workers pull; Workly pushes. Since the work happens in an HTTP request to your app, the moving parts around it go away.
Workly and BullMQ compared.
Both deliver at least once, retry with backoff, rate-limit a queue across all consumers and deduplicate jobs. The differences are in what you operate, what's on by default, and what you can see afterwards.
| BullMQ | Workly | |
|---|---|---|
| Model | Workers pull jobs from Redis or Postgres and run your processor function | Workly pushes each task to your endpoint as an HTTP request |
| What you run | Redis 6.2+ (or Postgres 13+) and worker processes; a dashboard is separate | One server plus Postgres, or hosted at workly.run. Your handlers run in the app you already deploy |
| Languages | Workers in Node.js, Bun, Python, Elixir, .NET and Rust; PHP can only add jobs. New features land in Node.js first | Any: a handler is an HTTP endpoint. TypeScript and Python SDKs, a CLI and an HTTP API |
| Local development | Start Redis and a worker next to your app | workly dev: SQLite, the dashboard and an echo target, no configuration |
| Retries | One attempt unless you set attempts; then fixed, exponential or custom backoff, jitter off by default | On by default: 5 attempts, backoff with jitter, honours Retry-After, and you choose whether 4xx is retried |
| Settings | Per job when it is added (attempts, backoff), and per worker (concurrency, limiter) | Per queue, in workly.yaml or the API; a task can override attempts and timeout |
| Rate limits | limiter per queue, shared by all workers; per-group limits need BullMQ Pro | rate_per_second and max_concurrency per queue, across all deliveries |
| Timeouts | None built in: abort inside your processor | timeout_seconds per queue, up to 30 minutes per attempt |
| Lost work | At-least-once: a stalled job goes back to waiting, and fails after too many stalls | At-least-once: an attempt cut short is recorded as lost and delivered again |
| Deduplication | A custom jobId while the job exists, or a deduplication ID with throttle and debounce modes | idempotency_key, for as long as the task is kept, and a stable Workly-Task-Id header |
| After the last retry | The failed set with the stack trace, kept until removeOnFail removes it | Kept as failed with every attempt, grouped by error; an alert by email or Slack; retry one or a whole group once the fix is in |
| Schedules | Job schedulers: cron with tz, or every N ms; a run only starts when a worker picks it up | Cron with a timezone, overlap policy, run history and run-now, in the same server |
| Flows | Parent jobs that wait for their children and read their results, built at runtime and nested as deep as you like | Workflows: DAGs of steps declared up front, where a step can wait for a task group; retry a failed run from where it stopped. Task groups for fan-in on their own |
| Visibility | Events, Prometheus metrics and OpenTelemetry; a UI from Taskforce.sh or Bull Board | Built-in dashboard with every attempt, MCP for coding agents, and Prometheus metrics when self-hosted |
| Price | Free, MIT. BullMQ Pro (groups, batches) from $139 a month per deployment; Taskforce.sh from $19.95 a month | Free to self-host, Apache-2.0. Hosted: 100k tasks a month free |
BullMQ behaviour from its documentation, bullmq.io and taskforce.sh, November 2026.
A processor becomes a route.
The processor's body stays the same. It moves behind a route, gets its data from the JSON payload, and answers 2xx when it's done; anything else is retried. Retries, rate limits and the timeout move from every add and every worker into the queue, in a file you deploy with your app.
import { Queue, Worker } from "bullmq";
const connection = { host: "localhost", port: 6379 };
const emails = new Queue("emails", { connection });
// In a request handler: settings travel with each job
await emails.add(
"send-email",
{ userId },
{ attempts: 5, backoff: { type: "exponential", delay: 1000 } },
);
// worker.ts, deployed and scaled on its own
new Worker(
"emails",
async (job) => {
await sendEmail(job.data.userId); // no timeout unless you add one
},
{ connection, concurrency: 10, limiter: { max: 5, duration: 1000 } },
);import { SignatureVerificationError, Workly, verifySignature } from "@worklydev/sdk";
const workly = new Workly(); // WORKLY_URL, WORKLY_API_KEY
// In a request handler
await workly.tasks.enqueue("emails", {
url: "https://api.example.com/tasks/send-email",
payload: { userId },
});
// The job is a route in the app you already run
// (app/tasks/send-email/route.ts, or any Fetch API handler)
export async function POST(req: Request) {
const body = await req.text();
try {
await verifySignature(body, req.headers);
} catch (err) {
if (err instanceof SignatureVerificationError) return new Response(null, { status: 401 }); // not retried
throw err;
}
await sendEmail(JSON.parse(body).userId);
return new Response(null, { status: 204 });
}# workly.yaml, applied with `workly deploy`
version: 1
queues:
emails:
max_attempts: 5
rate_per_second: 5
max_concurrency: 10
timeout_seconds: 60And job schedulers become schedules.
Both run cron in your timezone. A Workly schedule doesn't wait for a worker to be free: it runs on the server, decides what happens when last night's run is still going, keeps each run with its attempts, and has a button to run one now.
const reports = new Queue("reports", { connection });
await reports.upsertJobScheduler(
"nightly-report",
{ pattern: "0 3 * * *", tz: "Europe/Stockholm" },
{ name: "nightly-report" },
);
// Runs when a worker for "reports" picks it up# workly.yaml
version: 1
schedules:
nightly-report:
cron: "0 3 * * *"
timezone: Europe/Stockholm
url: https://api.example.com/tasks/nightly-report
overlap: skip # if last night's run is still goingSee why a job failed without another dashboard.
Every task keeps its attempts: status code, error, response body and timing. Failed tasks are grouped by error, so after a bad deploy you fix the handler and retry the whole group, from the dashboard, the CLI or your coding agent over MCP. Failures can alert you by email or Slack, and queue depth, delivery rate and the age of the oldest due task are in the dashboard too.

When BullMQ is the better choice.
Throughput is the point
BullMQ on Redis moves tens of thousands of jobs a second, with priorities, LIFO and batches. Workly delivers each task as an HTTP request and stores it in Postgres, which is plenty for most apps but not for that.
Jobs are long or flows are built at runtime
A BullMQ worker can run a job for hours, and a flow can add children as it runs and hand their results to the parent. Workly's attempts stop at 30 minutes, and its workflows are declared up front, with no results passed between steps.
There is no HTTP service
Workly needs an endpoint to call. If your jobs run in scripts or workers with no web server in front of them, BullMQ fits better.
Questions
- Does Workly replace Redis?
- For background jobs, yes. Workly stores tasks in Postgres (or SQLite on your laptop) and delivers them itself, so there is no Redis to size, persist or watch for memory. Hosted Workly needs no database on your side at all.
- Where does the work run?
- In your app. Each task is an HTTP request to a route you expose, so it runs in your Node.js service, or in a separate service just for jobs if you want to keep them apart. Scale it like any web service.
- Does it work on Vercel, Cloudflare Workers or Lambda?
- Yes, and that's where BullMQ is hard: a serverless function can't keep a worker running. With Workly, enqueueing is one HTTP request and each task arrives as an ordinary request to your route. Keep each attempt under the platform's time limit.
- BullMQ has a Postgres backend now. Is that the same thing?
- It replaces Redis, but you still run workers that pull jobs and execute your code. Workly keeps the jobs in Postgres and also does the delivering, so the work runs in your app over HTTP.
- What about Bull, Agenda or Bee-Queue?
- The same comparison holds: they are worker queues with a store to run. Bull is in maintenance mode, and its successor is BullMQ. Workly trades the workers for HTTP delivery and adds retries by default, timeouts, schedules and attempt history.
- How do I move over gradually?
- Queue by queue. Turn one processor into a route, create a queue for it, and enqueue to Workly instead of calling queue.add. Keep the old worker running until its jobs drain, then move its job schedulers to Workly schedules.
Try it in five minutes.
The install script and workly dev give you a server and dashboard on your laptop, with nothing else to start, and npm install @worklydev/sdk lets your app enqueue to it. Or sign in to hosted Workly and get a workspace and an API key in a minute, free on the Hobby plan.