Flower Alternative: z4j vs. Flower for Celery Monitoring
The classic Celery viewer. Built in 2011.
- Scope
- Celery only
- Positioning
- Read-only viewer
- License
- BSD-3, open source
Credit where it's due
Reasons to choose z4j over Flower
Persistent task history (Postgres-backed)
Flower keeps tasks in memory; everything vanishes on restart. z4j stores task records in its database and records operator actions in an HMAC-chained audit log, so retained history remains searchable across brain restarts.
Real actions, not a viewer
Retry, cancel, bulk-retry, purge-queue with filters. Flower is read-only by design, z4j is built for operators who need to fix things, not just watch them. Which controls appear depends on what the connected adapter advertises; the Celery adapter does not offer dead-letter replay, because a generic retry cannot consume and acknowledge a broker-specific DLQ entry.
Full schedule CRUD for Celery Beat
Create, edit, delete, enable/disable, and trigger-now from the UI. Flower's beat viewer is read-only and doesn't write back to your scheduler config.
RBAC + invitations + password reset
Admin / Operator / Viewer roles per project. Mint invitation links, SMTP auto-send, single-use tokens. Flower's single basic-auth user was always a compromise.
Multi-engine, not Celery-only
If half your stack is Celery and half is RQ or Dramatiq or arq, z4j is one dashboard and one audit log for all of it. Task controls appear only where the adapter advertises the required capability, and dashboard updates use a session-authenticated WebSocket.
Tamper-evident audit log
Every task action and config change lands on an HMAC-chained log with a separately authenticated head, so a write that skipped the audit service is detected rather than assumed away. Flower keeps no record at all, so evidence-gathering is a Slack-screenshot scramble. z4j is not a compliance certification and the chain is not evidence against whoever holds the database credentials, but it is a signed record of who ran which privileged action, which is a far better starting point than a screenshot.
Reconciliation closes the 'task stuck on started' gap
Workers crash. Flower never finds out and the task sits as 'started' forever. z4j's reconciler probes the result backend and closes the loop automatically.
Secret redaction is built in
Recursive scrubber on args/kwargs/exception payloads, with per-task overrides. Flower shows raw arguments in the UI, one of the top reasons teams move off it.
z4j vs. Flower, feature by feature
| Capability | Flower | z4j |
|---|---|---|
| Engine coverage | Celery only | Celery, RQ, Dramatiq, Huey, arq, taskiq |
| Persistent history | In-memory only, lost on restart | Database-backed retained task history |
| Actions (retry, cancel, bulk) | None, strictly a viewer | Capability-aware; each adapter advertises only the actions it can execute safely |
| Bulk operations | None | bulk_retry, purge_queue with filters |
| Schedule management | Read-only via Celery Beat viewer | Full CRUD: create, edit, delete, enable/disable, trigger-now |
| RBAC / multi-user | Single basic-auth user | Admin / Operator / Viewer per project |
| Invitation flow | None | Admin mints links, SMTP auto-send, single-use tokens |
| Password reset | N/A (no user model) | Constant-shape response, single-use tokens, session revoke |
| Audit log | None | HMAC-chained, tamper-evident |
| Reconciliation worker | None - tasks stuck 'started' stay that way | Periodic probe closes the gap automatically |
| Historical trends | None | Built-in: success, failure, retry and revoke counts plus average runtime over time |
| Visual DAG (chains/groups/chords) | Flat parent/child list | Tidy-tree SVG with runtime badges |
| Secret redaction | Raw args shown in UI | Recursive scrubber + per-task overrides |
| Notifications | None | Email / Slack / Telegram / webhook, SSRF-hardened |
| Real-time updates | Broker event stream, UI polls the Flower API | Session-authenticated dashboard WebSocket |
Cut over from Flower in a week (or a weekend)
- 1
Keep Flower running during the migration
z4j and Flower don't interfere. Leave Flower up; install z4j alongside; compare views during the cut-over week. Turn Flower off when you're confident.
- 2
Install the z4j-celery adapter in the same worker process
Flower subscribes to Celery's broker events via a separate process. z4j-celery uses the same events, plus worker signals, plus the result backend for reconciliation. Both can observe concurrently.
- 3
Point z4j at the same broker + result backend
z4j reads your existing CELERY_BROKER_URL + CELERY_RESULT_BACKEND. No data migration. Historical tasks that Flower forgot on its last restart won't appear in z4j, but task records captured after z4j starts persist across brain restarts until an operator deletes them.
- 4
Mint per-operator users
Flower's single-user basic-auth was always a compromise. z4j has real RBAC: invite your team, give each person a login, make operators actual operators. Audit log shows who retried what and when.
- 5
Delete your Flower docker-compose entry
Keep the compose file in git. If you hit a z4j bug, you can re-enable Flower in one minute. You won't need to.
z4j vs. Flower: FAQ
Is z4j a drop-in replacement for Flower?
z4j observes the same Celery broker events Flower does, plus worker signals and the result backend. You can run both side by side during the cut-over and turn Flower off when you're ready. There is no data migration; z4j picks up tasks from the moment it starts.
Does z4j work with Celery Beat?
Yes. The z4j-celerybeat adapter exposes full schedule CRUD: create, edit, delete, enable/disable, and trigger-now from the UI. Writes go back to the scheduler your worker reads, whether that is django-celery-beat or the static beat_schedule.
Is z4j open source?
Yes. z4j (server + dashboard + API) is AGPL-3.0-or-later. The agents that ship inside your worker are Apache 2.0, safe to import into any project, commercial or otherwise. Source on GitHub at github.com/z4jdev.
Can I self-host z4j?
Self-hosting is the default. There is no SaaS option. Three deployment paths: pip + SQLite (homelab / single dev), Docker + SQLite (small teams), Docker + Postgres (production). One docker compose up and you're running.
Does z4j support engines other than Celery?
Yes. Celery, RQ, Dramatiq, Huey, arq, and taskiq all feed the same dashboard and audit surface. Task controls are capability-aware: retry, cancel, bulk, and queue controls appear only where the connected adapter can execute them safely.
How does z4j compare to Flower for performance overhead?
Both observe Celery broker events, but their storage and rendering paths differ: z4j persists incoming events while Flower keeps state in memory. Throughput and overhead depend on worker load, database sizing, retention, and dashboard use, so benchmark both against your own event rate before choosing capacity.
What about Flower's HTTP API?
z4j has a richer REST + WebSocket API documented at z4j.dev/api/overview/. Anything you scripted against Flower's API has an equivalent in z4j (usually with more filters and a tamper-evident audit trail of who called it).
Where we don't win
Flower has been around since 2011. It is battle-tested on Celery in a way a much younger project is not, and that maturity is real.
Flower is a single-process deploy: one container, no database. z4j needs SQLite at minimum, Postgres for production. That is a real operational delta.
If your stack is pure Celery and you only need a viewer, Flower is fine.
Compared to other dashboards
Try z4j alongside Flower, no migration required
Run both for a week. Compare. Decide.