Workly

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.

With Celery
With Workly
Redis or RabbitMQ
Postgres, which you likely run already
Worker processes, deployed with your code
Your app, which already serves HTTP
celery beat, exactly one
Schedules, in the same server
A result backend, for chords and results
Task groups, workflows and attempt history, built in
Flower, for a look inside
The dashboard, built in

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.

CeleryWorkly
ModelWorkers pull jobs from a broker and run your Python functionsWorkly pushes each task to your endpoint as an HTTP request
What you runA broker (Redis or RabbitMQ), worker processes, celery beat for periodic tasks, and Flower or similar to see insideOne server plus Postgres, or hosted at workly.run. Your handlers run in the app you already deploy
LanguagesPythonAny: a handler is an HTTP endpoint. Python and TypeScript SDKs
Local developmentStart the broker, a worker and beat, and restart workers when code changesworkly dev: SQLite, dashboard and an echo target, no configuration
RetriesOpt in per task (autoretry_for, retry_backoff, max_retries)On by default: backoff with jitter, honours Retry-After, per-queue policy
Lost workAcknowledged before running unless acks_late is set, so a crashed worker can drop a taskAt-least-once: an attempt cut short is recorded as lost and delivered again
Rate limitsrate_limit per task, enforced by each worker separatelyrate_per_second and max_concurrency per queue, across all deliveries
Delayed taskscountdown or eta; held in worker memory, and with Redis redelivered after the visibility timeoutdelay_seconds or run_at, stored in the database until due
DeduplicationNot built inidempotency_key on enqueue, and a stable Workly-Task-Id header
Periodic taskscelery beat, a separate process; run exactly oneSchedules in the same server: cron in your timezone, run history, run-now
Fan-inChords, which need a result backendTask groups: one callback with the counts when every task has finished
WorkflowsCanvas: chains, groups and chords, with results passed between tasks through the result backendDAGs 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 retryThe exception in the result backend, if configured, until results expireKept as failed with every attempt, grouped by error; retry one or all once the fix is in
VisibilityFlower, a separate service; or logsBuilt-in dashboard, MCP for coding agents, and Prometheus metrics when self-hosted
Job lengthNo limit by defaultOne 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.

Celery
# 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 worker
Workly
from 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 "", 204

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

Celery beat
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
# workly.yaml, applied with `workly deploy`
version: 1
schedules:
  nightly-report:
    cron: "0 3 * * *"
    timezone: Europe/Stockholm
    url: https://api.example.com/tasks/nightly-report

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

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

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.