Workly

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.

With BullMQ
With Workly
Redis (or Valkey, Dragonfly), sized and persisted for the queue
Postgres, which you likely run already, or nothing at all when hosted
Worker processes, deployed and scaled alongside your app
Your app, which already serves HTTP
A timeout in every processor, since jobs have none built in
A timeout per queue, enforced on every attempt
Taskforce.sh (from $19.95 a month) or Bull Board, to see inside
The dashboard, built in, with alerts by email and Slack

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.

BullMQWorkly
ModelWorkers pull jobs from Redis or Postgres and run your processor functionWorkly pushes each task to your endpoint as an HTTP request
What you runRedis 6.2+ (or Postgres 13+) and worker processes; a dashboard is separateOne server plus Postgres, or hosted at workly.run. Your handlers run in the app you already deploy
LanguagesWorkers in Node.js, Bun, Python, Elixir, .NET and Rust; PHP can only add jobs. New features land in Node.js firstAny: a handler is an HTTP endpoint. TypeScript and Python SDKs, a CLI and an HTTP API
Local developmentStart Redis and a worker next to your appworkly dev: SQLite, the dashboard and an echo target, no configuration
RetriesOne attempt unless you set attempts; then fixed, exponential or custom backoff, jitter off by defaultOn by default: 5 attempts, backoff with jitter, honours Retry-After, and you choose whether 4xx is retried
SettingsPer 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 limitslimiter per queue, shared by all workers; per-group limits need BullMQ Prorate_per_second and max_concurrency per queue, across all deliveries
TimeoutsNone built in: abort inside your processortimeout_seconds per queue, up to 30 minutes per attempt
Lost workAt-least-once: a stalled job goes back to waiting, and fails after too many stallsAt-least-once: an attempt cut short is recorded as lost and delivered again
DeduplicationA custom jobId while the job exists, or a deduplication ID with throttle and debounce modesidempotency_key, for as long as the task is kept, and a stable Workly-Task-Id header
After the last retryThe failed set with the stack trace, kept until removeOnFail removes itKept 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
SchedulesJob schedulers: cron with tz, or every N ms; a run only starts when a worker picks it upCron with a timezone, overlap policy, run history and run-now, in the same server
FlowsParent jobs that wait for their children and read their results, built at runtime and nested as deep as you likeWorkflows: 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
VisibilityEvents, Prometheus metrics and OpenTelemetry; a UI from Taskforce.sh or Bull BoardBuilt-in dashboard with every attempt, MCP for coding agents, and Prometheus metrics when self-hosted
PriceFree, MIT. BullMQ Pro (groups, batches) from $139 a month per deployment; Taskforce.sh from $19.95 a monthFree 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.

BullMQ
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 } },
);
Workly
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
# workly.yaml, applied with `workly deploy`
version: 1
queues:
  emails:
    max_attempts: 5
    rate_per_second: 5
    max_concurrency: 10
    timeout_seconds: 60

And 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.

BullMQ
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
# 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 going

See 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.

A failed task in the Workly dashboard, explaining why it failed, with every attempt's response.

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.