Celery alternative
Background jobs without workers or a broker.
Celery runs your jobs in workers that pull from Redis or RabbitMQ, and that's a lot to run: the broker, the workers, beat, and something to see inside. Workly turns it around. Your job is an endpoint in the app you already deploy, and Workly calls it, with retries, 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 Celery compared.
Both run your code later and retry it when it fails. The differences are in what you operate, what's on by default, and what you can see afterwards.
| Celery | Workly | |
|---|---|---|
| Model | Workers pull jobs from a broker and run your Python functions | Workly pushes each task to your endpoint as an HTTP request |
| What you run | A broker (Redis or RabbitMQ), worker processes, celery beat for periodic tasks, and Flower or similar to see inside | One server plus Postgres, or hosted at workly.run. Your handlers run in the app you already deploy |
| Languages | Python | Any: a handler is an HTTP endpoint. Python and TypeScript SDKs |
| Local development | Start the broker, a worker and beat, and restart workers when code changes | workly dev: SQLite, dashboard and an echo target, no configuration |
| Retries | Opt in per task (autoretry_for, retry_backoff, max_retries) | On by default: backoff with jitter, honours Retry-After, per-queue policy |
| Lost work | Acknowledged before running unless acks_late is set, so a crashed worker can drop a task | At-least-once: an attempt cut short is recorded as lost and delivered again |
| Rate limits | rate_limit per task, enforced by each worker separately | rate_per_second and max_concurrency per queue, across all deliveries |
| Delayed tasks | countdown or eta; held in worker memory, and with Redis redelivered after the visibility timeout | delay_seconds or run_at, stored in the database until due |
| Deduplication | Not built in | idempotency_key on enqueue, and a stable Workly-Task-Id header |
| Periodic tasks | celery beat, a separate process; run exactly one | Schedules in the same server: cron in your timezone, run history, run-now |
| Fan-in | Chords, which need a result backend | Task groups: one callback with the counts when every task has finished |
| Workflows | Canvas: chains, groups and chords, with results passed between tasks through the result backend | DAGs of HTTP steps in workly.yaml; a step can wait for a task group; a failed run retries from where it stopped |
| After the last retry | The exception in the result backend, if configured, until results expire | Kept as failed with every attempt, grouped by error; retry one or all once the fix is in |
| Visibility | Flower, a separate service; or logs | Built-in dashboard, MCP for coding agents, and Prometheus metrics when self-hosted |
| Job length | No limit by default | One HTTP request: up to 30 minutes per attempt |
Celery behaviour from its documentation (5.x), October 2026.
A task becomes an endpoint.
The function body stays the same. It moves behind a route, gets its arguments from the JSON payload, and answers 2xx when it's done; anything else is retried.
# tasks.py
from celery import Celery
app = Celery("app", broker="redis://localhost:6379/0")
@app.task(autoretry_for=(Exception,), retry_backoff=True, max_retries=5)
def send_email(user_id):
...
# In a request handler
send_email.delay(123)
# And in production, alongside the app:
# redis-server
# celery -A tasks workerfrom workly import SignatureVerificationError, Workly, verify_signature
workly = Workly() # WORKLY_URL, WORKLY_API_KEY
# In a request handler
workly.tasks.enqueue(
"emails",
url="https://api.example.com/tasks/send-email",
payload={"user_id": 123},
)
# The task is an endpoint in the app you already run
@app.post("/tasks/send-email")
def send_email():
try:
verify_signature(request.get_data(), request.headers)
except SignatureVerificationError:
abort(401)
user_id = request.get_json()["user_id"]
...
return "", 204And celery beat becomes a schedule.
No extra process to keep at exactly one replica. Schedules run on the Workly server, are retried and signed like tasks, and each run is recorded, with a button to run one now.
from celery.schedules import crontab
app.conf.timezone = "Europe/Stockholm"
app.conf.beat_schedule = {
"nightly-report": {
"task": "tasks.nightly_report",
"schedule": crontab(hour=3, minute=0),
},
}
# Plus exactly one of:
# celery -A tasks beat# workly.yaml, applied with `workly deploy`
version: 1
schedules:
nightly-report:
cron: "0 3 * * *"
timezone: Europe/Stockholm
url: https://api.example.com/tasks/nightly-reportSee why a job failed without Flower.
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. Queue depth, delivery rate and the age of the oldest due task are in the dashboard.

When Celery is the better choice.
Jobs run longer than 30 minutes
Each Workly attempt is one HTTP request. Video encoding or multi-hour batch jobs belong on workers, or split into tasks that each fit in a request.
Steps pass results or branch
Celery's canvas passes each task's result to the next and builds chains at runtime. Workly's workflows are declared up front, with no conditions or outputs between steps: a step reads what an earlier one stored. If you need more, keep canvas, or look at Temporal.
There is no HTTP service
Workly needs an endpoint to call. If your jobs live in scripts or a data pipeline with no web server, workers fit better.
Questions
- Does Workly replace Redis or RabbitMQ?
- For background jobs, yes. Workly stores tasks in Postgres (or SQLite on your laptop) and delivers them itself, so there is no separate broker. Hosted Workly needs no database at all on your side.
- Where does the work run?
- In your app. Each task is an HTTP request to an endpoint you expose, so it runs in your web service, or in a separate service just for jobs if you want to keep them apart. Scale it like any web service.
- Is it only for Python?
- No. Handlers are plain HTTP endpoints in any language. There are Python and TypeScript SDKs for enqueueing and checking signatures, a CLI, and a documented HTTP API for everything else.
- What about RQ, Dramatiq or Sidekiq?
- The same comparison holds: they are worker queues with a broker to run. Workly trades the workers for HTTP delivery, and adds retries by default, rate limits per queue, schedules and attempt history.
- Is HTTP delivery slower than a worker?
- Slightly: each task is an HTTP request. In Workly's load tests on one server, the median from enqueue to delivery was a few milliseconds at 1,000 tasks a second. For background jobs that is rarely what matters.
- How do I move over gradually?
- Queue by queue. Turn one Celery task into an endpoint, enqueue it with Workly instead of .delay(), and keep the rest on Celery until you're ready. The two don't interfere.
Try it in five minutes.
pip install "workly[cli]" and workly dev give you a server and dashboard on your laptop, with nothing else to start. Or sign in to hosted Workly and get a workspace and an API key in a minute, free on the Hobby plan.