Flower Alternative: z4j vs. Flower for Celery Monitoring
The classic Celery viewer.
- Scope
- Celery only
- Positioning
- Celery monitoring and remote control
- License
- BSD-3, open source
what Flower does well
Credit where it's due
why teams switch
Reasons to choose z4j over Flower
Persistent task history (database-backed)
Flower can persist its state when persistent mode is enabled. 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.
Task operations with project roles and audit records
Retry, cancel, filtered bulk retry, and queue purge through the API. Flower also provides task and worker controls. z4j combines supported actions across engines with project roles and an audit trail. 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
Native database Beat writes go to django-celery-beat and wait for source confirmation, with matching z4j package versions on the server and in the producer. Static beat_schedule entries remain read-only except immediate triggering. Flower documents ETA/countdown task views rather than a PeriodicTask editor.
RBAC + invitations + password reset
Admin / Operator / Auditor / Viewer roles per project. Mint invitation links, SMTP auto-send, single-use tokens. Flower supports multiple basic-auth users and OAuth; z4j adds project roles and invitations.
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 run only where the adapter advertises the required capability, and dashboard updates use a session-authenticated WebSocket.
Tamper-evident audit log
Task actions and configuration changes land on an HMAC-chained log with a separately authenticated head, so a write that skipped the audit service is detected rather than assumed away. 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
Worker crashes can leave event-derived task state incomplete. 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 also supports filtering task details with its format_task customization hook.
capability matrix
z4j vs. Flower, feature by feature
| Capability | Flower | z4j |
|---|---|---|
| Engine coverage | Celery only | Celery, RQ, Dramatiq, Huey, arq, taskiq |
| Persistent history | Optional persistent mode with a local database file | Database-backed retained task history |
| Actions (retry, cancel, bulk) | Task revoke/terminate and worker controls through UI/API | Capability-aware; each adapter advertises only the actions it can execute safely |
| Bulk operations | Celery remote-control API | Filtered bulk_retry; whole-queue purge_queue through the API |
| Schedule management | Scheduled ETA/countdown tasks; no documented PeriodicTask editor | z4j-owned CRUD; native database Beat writes with source confirmation; static definitions read-only |
| RBAC / multi-user | Multiple basic-auth users and OAuth; different authorization model | Admin / Operator / Auditor / 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 | Celery event monitoring and worker inspection | Periodic probe closes the gap automatically |
| Historical trends | Task views and Prometheus integration | Built-in: success, failure 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 | Custom format_task hook can filter sensitive fields | Recursive scrubber + per-task overrides |
| Notifications | None | Email / Slack / Telegram / webhook, SSRF-hardened |
| Real-time updates | Live view fed by the broker event stream | Session-authenticated dashboard WebSocket |
migration guide
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. Existing Flower history is not imported into z4j, but task records captured after z4j starts persist across brain restarts until an operator deletes them.
- 4
Mint per-operator users
Flower supports multiple basic-auth users and OAuth. 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. Keep the rollback path until your own workload passes validation.
frequently asked
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. z4j supports create, edit, delete, enable/disable and trigger-now from the UI for django-celery-beat PeriodicTasks, with matching z4j package versions on the server and in the producer. Writes require django-celery-beat and a connected adapter with native-write support. Static beat_schedule is read-only except immediate triggering. See the Beat guide for the supported setup.
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 guided paths: pip + SQLite (homelab / single dev), Docker + SQLite (small teams), Docker + Postgres (production), and the sdist also ships a Helm chart, raw Kubernetes manifests and systemd units for shops that run those. 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 and bulk actions run only where the connected adapter advertises them.
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 in its database while Flower has optional state persistence. 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 docs.z4j.com/api/overview/. The APIs differ. Check each operation and adapter capability before migrating an existing script.
honest trade-offs
Where we don't win
Flower has been around for over a decade. 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 a database: SQLite for a single instance, PostgreSQL for replicas and scale. That is a real operational delta.
If your stack is pure Celery and you only need a viewer, Flower is fine.
other comparisons
Compared to other dashboards
Try z4j alongside Flower, no migration required
Run both for a week. Compare. Decide.