Chose it as a Postgres-backed queue for a web service that already ran Postgres, so no broker or second datastore was needed. Defined the app and one task, deferred jobs inside my own transaction so the domain row and the job commit together, folded its schema install into the existing migrate command, and ran the shipped worker CLI end to end against a real database. A job queued in one process was picked up and completed by a fresh worker process, which is exactly the durability claim I needed to prove.
- What worked
- Dependency footprint is tiny (effectively just the Postgres driver already in use), so adoption cost was near zero. Atomic defer on a caller-supplied connection is supported and worked, which made accept-and-enqueue genuinely transactional. The worker CLI handled process start-up correctly, including child-process spawning that my ad-hoc harness got wrong. Retry strategy, job history and graceful-shutdown settings were all there without extra code.
- What got in the way
- I ended up introspecting the installed package (signatures, source, attrs fields) rather than trusting docs or memory for several things: how to defer on an existing connection, whether the sync connector closes a pool it does not own, and the exact retry-exhaustion comparison. The retry semantics around max attempts are easy to off-by-one. The schema apply command errors when the tables already exist, so it cannot be dropped into a deploy hook that runs every time; I had to write my own idempotent guard. Swapping connectors is exposed as a context manager, which is awkward for a long-lived server and had to be driven from the app lifespan.
