Benchmark results · 2026-11-11 to 2026-11-15

Eight Postgres-backed queues, one host, the same scenarios.

Every system ran the same scenarios, one after another, against a fresh PostgreSQL 18.6 cluster capped at 4 CPUs, on one host, in November 2026. In saturation, the Postgres restart and many queues, every system had a pool of workers + 8 connections per process. In the other scenarios Awa and Absurd had that pool and the other systems their adapter's default (4 connections for Procrastinate, 10 for pg-boss). Absolute numbers depend on this host; the comparisons within a section are the point.

Maintained by Awa’s author.

Every adapter, scenario and raw summary is in the repository, and every run can be repeated on your own hardware. Corrections from the maintainers of any system are welcome.

HostAMD Ryzen 9 5900X 12-Core Processor24 threads · 61 GB · Linux 7.0.0-43-generic
DatabasePostgreSQL 18.6postgres:18.6-alpine · capped at 4 CPUs · data on NVMe · fresh cluster per run
Settingssynchronous_commit onshared_buffers 256MB · max_connections 400 · stock autovacuum
Runs161 cellsharness 62f22cd208, 1964ee5be1, 50b978ae46, 728683164e, 7ea04c3fec

Systems and versions

SystemLibraryVersionContract
Absurdabsurd-sdk0.5.1Durable workflow
Awaawa0.6.17+git.1a53fd9eJob framework
Obanoban2.24.2Job framework
pg-bosspg-boss12.38.2Job framework
PGMQpgmq extensionv1.13.1Visibility queue
PgQuepgquev0.3.0-alpha.1-30-g8e3064cEvent queue
Procrastinateprocrastinate3.11.0Job framework
Rivergithub.com/riverqueue/riverv0.51.2Job framework

Four contracts

Job frameworks

AwaObanpg-bossProcrastinateRiver

A job is claimed by one worker, retried with backoff and completed or failed individually.

Durable workflow

Absurd

Tasks run as checkpointed steps that replay after an interruption; driven here as one-step jobs through its worker.

Visibility queue

PGMQ

A message becomes invisible when read and reappears unless deleted; no per-job retry policy, scheduling or dead-letter handling beyond its archive.

Event queue (PgQ lineage)

PgQue

Consumers read batches cut by a ticker and acknowledge a whole batch in one statement. Driven here as competing consumers; batch acknowledgement is a lighter contract than per-job completion.

At a glance

One headline measurement per scenario. The bar shows where each value falls between the best and worst in its row (longer is better); bars never compare across rows, and nothing is added up. Each row links to the full scenario.

ScenarioAbsurdworkflowAwaObanpg-bossPGMQvisibility queuePgQueevent batchesProcrastinateRiver
Jobs/s, 64 workershigher is better578 jobs/s5,689 jobs/s3,993 jobs/s2,248 jobs/s5,379 jobs/s18.9K jobs/s459 jobs/s1,267 jobs/s
Pickup p99 at 800 jobs/slower is better1.99 min19 ms20 ms410 ms7 ms107 ms47.1 s43.7 s
Idle transactions/slower is better23.5 xacts/s60.1 xacts/s16 xacts/s21.9 xacts/s160 xacts/s40.6 xacts/s65.5 xacts/s24 xacts/s
Jobs/s after a Postgres restarthigher is better802 jobs/s802 jobs/s802 jobs/s668 jobs/s399 jobs/s805 jobs/s775 jobs/s634 jobs/s
Neighbour p99, queue at 4×lower is better14 ms6 ms12 ms10 ms18 ms2 ms5 ms7 ms
Dead catalog tuples, stalled CDClower is better22 tuples11.4K tuples115 tuples139 tuples20 tuples114 tuples25 tuples214 tuples
Scheduled herd lateness p99lower is better2.28 min12 s20.5 s1.29 min1.94 s–41 s1.04 min
Good jobs/s in a failure stormhigher is better139 jobs/s138 jobs/s138 jobs/s132 jobs/s138 jobs/s138 jobs/s138 jobs/s138 jobs/s
Pickup p99 over 200 queueslower is better255 ms85 ms13 ms5 ms3 ms105 ms11 ms42 ms
Database after an 8 GiB drainlower is better8 GB21.3 MB8 GB8.35 GB16 GB8.33 GB7.35 GB8 GB
WAL/s with 40 s jobslower is better12.3 KB/s27.9 KB/s11.2 KB/s6.52 KB/s4.64 KB/s6.26 KB/s5.95 KB/s11.5 KB/s
Backlog drain ratehigher is better–5,154 jobs/s4,206 jobs/s2,510 jobs/s14.5K jobs/s14.3K jobs/s579 jobs/s1,226 jobs/s
1M abandoned jobs, all done againlower is better28.5 min20.5 minnot done in 30 min14 min5.88 min16.3 s32 min–

Throughput at saturation

How many 1 ms jobs per second does one worker process complete as it gets more workers?

Setup. Out of the box: the producer keeps 4,000 jobs queued; one worker process with 4, 16, 64 or 128 workers and a pool of workers + 8 connections; 30 s warmup, then 150 s measured. Tuned: each system at the settings its own documentation points to, within one budget for all: at most 4 processes, 128 handlers and 200 connections, the same 1 ms jobs, measured at one queue and at its recommended number of queues.

  • PgQue completes the most events (47,282/s tuned), but it acknowledges a batch at a time and its single producer was the limit: the queue stayed empty with Postgres at 1.1 cores, so treat it as a floor.
  • PGMQ peaks at 12,013/s with 16 workers. With more readers each pgmq.read scans past the others' in-flight rows, Postgres saturates and throughput falls (3,678/s at 128 workers; 5,710/s tuned over 16 queues).
  • Among job frameworks, tuned and sharded over 4 queues, River (10,905/s on 2.2 Postgres cores) and Awa (10,762/s on 4.0 cores) lead, then Oban (5,673/s), pg-boss (3,495/s, Postgres-bound), Absurd (1,625/s) and Procrastinate (1,472/s).
  • Configuration matters most for River (2,509/s at 128 workers with the adapter's 50 ms fetch cooldown) and Procrastinate (451/s on one process, 3.3× with four).
Reading it
  • PgQue and PGMQ provide lighter contracts than the job frameworks; compare them with each other, not with job frameworks.
  • Queue wait dominates claim latency here by design, so throughput is the figure to compare.
  • The tuned settings are listed below with their sources in each system's proposal; corrections from maintainers are welcome.
4 workers
01,0002,0003,0004,000PGMQ3,494 jobs/sPgQue3,215 jobs/spg-boss512 jobs/sAwa488 jobs/sProcrastinate474 jobs/sOban385 jobs/sAbsurd274 jobs/sRiver79.2 jobs/s
Table view
4 workers
System4 workers
PGMQ3,494 jobs/s
PgQue3,215 jobs/s
pg-boss512 jobs/s
Awa488 jobs/s
Procrastinate474 jobs/s
Oban385 jobs/s
Absurd274 jobs/s
River79.2 jobs/s
16 workers
05,00010K15KPGMQ12K jobs/sPgQue9,751 jobs/spg-boss2,048 jobs/sAwa1,717 jobs/sOban1,312 jobs/sProcrastinate454 jobs/sAbsurd440 jobs/sRiver317 jobs/s
Table view
16 workers
System16 workers
PGMQ12K jobs/s
PgQue9,751 jobs/s
pg-boss2,048 jobs/s
Awa1,717 jobs/s
Oban1,312 jobs/s
Procrastinate454 jobs/s
Absurd440 jobs/s
River317 jobs/s
64 workers
05,00010K15K20KPgQue18.9K jobs/sAwa5,689 jobs/sPGMQ5,379 jobs/sOban3,993 jobs/spg-boss2,248 jobs/sRiver1,267 jobs/sAbsurd578 jobs/sProcrastinate459 jobs/s
Table view
64 workers
System64 workers
PgQue18.9K jobs/s
Awa5,689 jobs/s
PGMQ5,379 jobs/s
Oban3,993 jobs/s
pg-boss2,248 jobs/s
River1,267 jobs/s
Absurd578 jobs/s
Procrastinate459 jobs/s
128 workers
010K20K30KPgQue23.3K jobs/sAwa8,573 jobs/sOban5,418 jobs/sPGMQ3,678 jobs/sRiver2,509 jobs/spg-boss2,240 jobs/sAbsurd614 jobs/sProcrastinate451 jobs/s
Table view
128 workers
System128 workers
PgQue23.3K jobs/s
Awa8,573 jobs/s
Oban5,418 jobs/s
PGMQ3,678 jobs/s
River2,509 jobs/s
pg-boss2,240 jobs/s
Absurd614 jobs/s
Procrastinate451 jobs/s
Best measured: completed jobs/sEach system's highest throughput over every configuration it ran, labelled with that configuration.
020K40K60KPgQue47.3K jobs/s · tuned, 1 queuePGMQ12K jobs/s · 16 workers, 1 processRiver10.9K jobs/s · tuned, 4 queuesAwa10.8K jobs/s · tuned, 4 queuesOban5,673 jobs/s · tuned, 1 queuepg-boss3,495 jobs/s · tuned, 1 queueAbsurd1,625 jobs/s · tuned, 4 queuesProcrastinate1,472 jobs/s · tuned, 1 queue
Table view
Best measured: completed jobs/s
SystemBest measured: completed jobs/s
PgQue47.3K jobs/s (tuned, 1 queue)
PGMQ12K jobs/s (16 workers, 1 process)
River10.9K jobs/s (tuned, 4 queues)
Awa10.8K jobs/s (tuned, 4 queues)
Oban5,673 jobs/s (tuned, 1 queue)
pg-boss3,495 jobs/s (tuned, 1 queue)
Absurd1,625 jobs/s (tuned, 4 queues)
Procrastinate1,472 jobs/s (tuned, 1 queue)
What configuration adds
Out of the box, 128 workersBest measured020K40K60KPgQue47.3K jobs/sPGMQ12K jobs/sRiver10.9K jobs/sAwa10.8K jobs/sOban5,673 jobs/spg-boss3,495 jobs/sAbsurd1,625 jobs/sProcrastinate1,472 jobs/s
Table view
What configuration adds
SystemOut of the box, 128 workersBest measured
PgQue23.3K jobs/s47.3K jobs/s
PGMQ3,678 jobs/s12K jobs/s
River2,509 jobs/s10.9K jobs/s
Awa8,573 jobs/s10.8K jobs/s
Oban5,418 jobs/s5,673 jobs/s
pg-boss2,240 jobs/s3,495 jobs/s
Absurd614 jobs/s1,625 jobs/s
Procrastinate451 jobs/s1,472 jobs/s
What sharding across queues addsSystems whose docs recommend sharding a hot queue. PGMQ's 16-queue run is in the table view.
Tuned, 1 queueTuned, 4 queues05,00010K15KRiver10.9K jobs/sAwa10.8K jobs/sAbsurd1,625 jobs/s
Table view
What sharding across queues adds
SystemTuned, 1 queueTuned, 4 queues
River8,113 jobs/s10.9K jobs/s
Awa8,550 jobs/s10.8K jobs/s
Absurd1,382 jobs/s1,625 jobs/s
Tuned settingsProcesses × handlers, queues and connections, plus each system's documented knobs.
Absurd4 × 32 handlers; 1 or 4 queues; producer batches of 256.
Awa1 × 128 handlers; 1 or 4 queues; 64 connections; lease rotation 1 s (the default); producer batches of 1,000.
Oban4 × 32 handlers; 1 queue; 40 connections each; dispatch_cooldown 1 ms (default 5 ms); producer batches of 1,000.
pg-boss4 × 32 handlers; 1 queue; pool of 40 each; batchSize 32, burstWhenBatchFull, LISTEN/NOTIFY; producer batches of 1,000.
PGMQ4 × 32 consumers; 1 or 16 queues, every consumer sweeping all queues; read batches of 32; ack with pgmq.delete; producer batches of 1,000.
PgQue4 processes × 4 cooperative subconsumers, 32 handlers each; 1 queue; ticker_loop every 10 ms; producer batches of 1,000.
Procrastinate4 × 32 handlers; 1 queue; pool of 33 each (concurrency + 1, as its docs advise); producer batches of 500.
River1 × 128 handlers; 1 or 4 queues; 32 connections; FetchCooldown 2 ms and FetchPollInterval 20 ms (River's own benchmark settings); producer batches of 1,000.
Peak dead tuples at 64 workersRows waiting for vacuum in the queue's tables while saturated.
1001,00010K100K1MAwa585 tuplesPgQue1,138 tuplesAbsurd34K tuplesProcrastinate54.6K tuplesRiver148K tuplespg-boss464K tuplesOban558K tuplesPGMQ867K tuples

Log scale.

Table view
Peak dead tuples at 64 workers
SystemPeak dead tuples at 64 workers
Awa585 tuples
PgQue1,138 tuples
Absurd34K tuples
Procrastinate54.6K tuples
River148K tuples
pg-boss464K tuples
Oban558K tuples
PGMQ867K tuples
All measurements in this scenario

4 workers

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)274 jobs/s488 jobs/s385 jobs/s512 jobs/s3,494 jobs/s3,215 jobs/s474 jobs/s79.2 jobs/s
Peak dead tuples (lower is better)239 tuples355 tuples46.2K tuples58.3K tuples448K tuples438 tuples49.7K tuples9,500 tuples
WAL per job (lower is better)2.25 KB2.37 KB4.3 KB2.55 KB1.7 KB428 B2.47 KB3.7 KB
Postgres CPU (lower is better)0.82 cores1.34 cores0.22 cores0.48 cores0.29 cores0.06 cores0.78 cores0.05 cores
Worker CPU (lower is better)0.13 cores0.15 cores0.36 cores0.08 cores0.13 cores0.14 cores0.7 cores0.02 cores
Postgres private memory, peak (lower is better)18.6 MB297 MB45.8 MB25 MB27.7 MB28.1 MB29.3 MB24.5 MB
Worker memory, peak (lower is better)44.8 MB11.5 MB2.13 GB65 MB43.3 MB55.8 MB40.4 MB10.3 MB
Database load (active sessions) (lower is better)0.97 sessions1.47 sessions0.68 sessions0.45 sessions0.51 sessions0.047 sessions1.86 sessions0.067 sessions

16 workers

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)440 jobs/s1,717 jobs/s1,312 jobs/s2,048 jobs/s12K jobs/s9,751 jobs/s454 jobs/s317 jobs/s
Peak dead tuples (lower is better)11.6K tuples353 tuples154K tuples243K tuples2.14M tuples725 tuples54.2K tuples37.6K tuples
WAL per job (lower is better)2.35 KB1.7 KB4.75 KB2.77 KB2.05 KB432 B2.48 KB3.77 KB
Postgres CPU (lower is better)0.74 cores1.44 cores0.58 cores1.95 cores1.73 cores0.12 cores0.81 cores0.06 cores
Worker CPU (lower is better)0.2 cores0.2 cores1.36 cores0.32 cores0.32 cores0.32 cores0.7 cores0.03 cores
Postgres private memory, peak (lower is better)19.4 MB345 MB76.4 MB47.9 MB67.5 MB30.6 MB29.6 MB21.7 MB
Worker memory, peak (lower is better)44.8 MB21 MB2.16 GB92.1 MB45.3 MB55.6 MB40.4 MB14.3 MB
Database load (active sessions) (lower is better)0.87 sessions1.47 sessions1 sessions2.11 sessions3.05 sessions0.16 sessions1.75 sessions0.053 sessions

64 workers

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)578 jobs/s5,689 jobs/s3,993 jobs/s2,248 jobs/s5,379 jobs/s18.9K jobs/s459 jobs/s1,267 jobs/s
Peak dead tuples (lower is better)34K tuples585 tuples558K tuples464K tuples867K tuples1,138 tuples54.6K tuples148K tuples
WAL per job (lower is better)2.47 KB1.52 KB5.4 KB3.13 KB2.01 KB436 B2.47 KB4.05 KB
Postgres CPU (lower is better)0.66 cores1.57 cores1.55 cores2.89 cores3.94 cores0.21 cores0.82 cores0.13 cores
Worker CPU (lower is better)0.25 cores0.37 cores4.13 cores0.35 cores0.27 cores0.62 cores0.7 cores0.09 cores
Postgres private memory, peak (lower is better)18.6 MB329 MB258 MB104 MB200 MB30.8 MB32.6 MB25 MB
Worker memory, peak (lower is better)45.1 MB63.7 MB2.2 GB201 MB50.2 MB55.6 MB40.4 MB16.2 MB
Database load (active sessions) (lower is better)0.79 sessions1.99 sessions11 sessions2.77 sessions41.6 sessions0.25 sessions1.96 sessions0.23 sessions

128 workers

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)614 jobs/s8,573 jobs/s5,418 jobs/s2,240 jobs/s3,678 jobs/s23.3K jobs/s451 jobs/s2,509 jobs/s
Peak dead tuples (lower is better)32.5K tuples570 tuples911K tuples471K tuples595K tuples1,308 tuples52.6K tuples325K tuples
WAL per job (lower is better)2.52 KB1.51 KB5.58 KB3.15 KB1.97 KB434 B2.46 KB4.28 KB
Postgres CPU (lower is better)0.63 cores1.64 cores2.33 cores3 cores4 cores0.25 cores0.76 cores0.23 cores
Worker CPU (lower is better)0.26 cores0.5 cores6.7 cores0.36 cores0.27 cores0.76 cores0.67 cores0.18 cores
Postgres private memory, peak (lower is better)18.4 MB332 MB432 MB128 MB345 MB30.4 MB33.9 MB27.9 MB
Worker memory, peak (lower is better)45.5 MB69.3 MB2.23 GB188 MB52.4 MB55.6 MB40.4 MB17.9 MB
Database load (active sessions) (lower is better)0.81 sessions1.7 sessions12.9 sessions2.89 sessions73.1 sessions0.33 sessions2.06 sessions0.31 sessions

Tuned, 1 queue

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)1,382 jobs/s8,550 jobs/s5,673 jobs/s3,495 jobs/s7,388 jobs/s47.3K jobs/s1,472 jobs/s8,113 jobs/s
Peak dead tuples (lower is better)92.2K tuples548 tuples1.05M tuples639K tuples1.55M tuples6,342 tuples172K tuples1.51M tuples
WAL per job (lower is better)2.64 KB1.54 KB6.45 KB3.79 KB1.35 KB443 B2.47 KB4.7 KB
Postgres CPU (lower is better)2.69 cores1.57 cores3.78 cores3.94 cores4 cores1.09 cores2.23 cores1.05 cores
Worker CPU (lower is better)0.64 cores0.51 cores6.2 cores0.77 cores0.39 cores1.9 cores2.02 cores0.52 cores
Postgres private memory, peak (lower is better)43.9 MB353 MB418 MB377 MB343 MB216 MB76.4 MB45.9 MB
Worker memory, peak (lower is better)173 MB71.8 MB8.65 GB340 MB177 MB260 MB162 MB19.9 MB
Database load (active sessions) (lower is better)3.86 sessions1.96 sessions23.3 sessions38.3 sessions104 sessions5.39 sessions5.39 sessions1.7 sessions

Tuned, 4 queues

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)1,625 jobs/s10.8K jobs/s–––––10.9K jobs/s
Peak dead tuples (lower is better)40.8K tuples708 tuples–––––2.2M tuples
WAL per job (lower is better)3.21 KB1.62 KB–––––5.25 KB
Postgres CPU (lower is better)3.99 cores3.96 cores–––––2.16 cores
Worker CPU (lower is better)0.95 cores0.83 cores–––––0.74 cores
Postgres private memory, peak (lower is better)103 MB456 MB–––––55.1 MB
Worker memory, peak (lower is better)173 MB77 MB–––––22.1 MB
Database load (active sessions) (lower is better)12.5 sessions5.01 sessions–––––4.41 sessions

Tuned, 16 queues

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)––––5,710 jobs/s–––
Peak dead tuples (lower is better)––––61.7K tuples–––
WAL per job (lower is better)––––1.33 KB–––
Postgres CPU (lower is better)––––4 cores–––
Worker CPU (lower is better)––––0.88 cores–––
Postgres private memory, peak (lower is better)––––382 MB–––
Worker memory, peak (lower is better)––––177 MB–––
Database load (active sessions) (lower is better)––––69.9 sessions–––

Best measured configuration

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)1,625 jobs/s10.8K jobs/s5,673 jobs/s3,495 jobs/s12K jobs/s47.3K jobs/s1,472 jobs/s10.9K jobs/s
Peak dead tuples (lower is better)40.8K tuples708 tuples1.05M tuples639K tuples2.14M tuples6,342 tuples172K tuples2.2M tuples
WAL per job (lower is better)3.21 KB1.62 KB6.45 KB3.79 KB2.05 KB443 B2.47 KB5.25 KB
Postgres CPU (lower is better)3.99 cores3.96 cores3.78 cores3.94 cores1.73 cores1.09 cores2.23 cores2.16 cores
Worker CPU (lower is better)0.95 cores0.83 cores6.2 cores0.77 cores0.32 cores1.9 cores2.02 cores0.74 cores
Postgres private memory, peak (lower is better)103 MB456 MB418 MB377 MB67.5 MB216 MB76.4 MB55.1 MB
Worker memory, peak (lower is better)173 MB77 MB8.65 GB340 MB45.3 MB260 MB162 MB22.1 MB
Database load (active sessions) (lower is better)12.5 sessions5.01 sessions23.3 sessions38.3 sessions3.05 sessions5.39 sessions5.39 sessions4.41 sessions

Latency at a steady 800 jobs/s

At a rate every system should sustain, how quickly does a job go from insert to completion?

Setup. 800 jobs/s offered, 32 workers, one process; 60 s warmup, then 300 s measured.

  • Awa, Oban and PGMQ pick up within 20 ms at p99; PgQue at 107 ms (its consumer's 100 ms poll); pg-boss at 410 ms.
  • River (634/s), Procrastinate (442/s) and Absurd (223/s) fell behind and their queues grew. River's adapter cooldown caps 32 workers at 640 jobs/s; Procrastinate and Absurd are limited per process (see saturation).
Reading it
  • A system that cannot keep up builds a backlog, and its latency grows for the whole run; those are marked with the rate they reached.
Pickup latency, p99Insert to a worker starting the job.
1 ms10 ms100 ms1 s10 s1 min10 minPGMQ7 msAwa19 msOban20 msPgQue107 mspg-boss410 msRiver43.7 s · reached 634 jobs/sProcrastinate47.1 s · reached 442 jobs/sAbsurd1.99 min · reached 223 jobs/s

Log scale.

Table view
Pickup latency, p99
SystemPickup latency, p99
PGMQ7 ms
Awa19 ms
Oban20 ms
PgQue107 ms
pg-boss410 ms
River43.7 s (reached 634 jobs/s)
Procrastinate47.1 s (reached 442 jobs/s)
Absurd1.99 min (reached 223 jobs/s)
WAL written per job
0 B2 KB4 KB6 KBPgQue457 BPGMQ1.47 KBAwa1.7 KBpg-boss2.8 KBProcrastinate3.1 KBRiver4.57 KBOban4.98 KBAbsurd5.19 KB
Table view
WAL written per job
SystemWAL written per job
PgQue457 B
PGMQ1.47 KB
Awa1.7 KB
pg-boss2.8 KB
Procrastinate3.1 KB
River4.57 KB
Oban4.98 KB
Absurd5.19 KB
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)223 jobs/s799 jobs/s800 jobs/s827 jobs/s803 jobs/s804 jobs/s442 jobs/s634 jobs/s
End-to-end p99 (lower is better)1.99 min21 ms–426 ms14 ms108 ms––
Claim p99 (lower is better)1.99 min19 ms20 ms410 ms7 ms107 ms47.1 s43.7 s
Queue depth (lower is better)95.7K jobs0 jobs9 jobs141 jobs1 jobs0 jobs28.9K jobs35K jobs
WAL per job (lower is better)5.19 KB1.7 KB4.98 KB2.8 KB1.47 KB457 B3.1 KB4.57 KB
Postgres CPU (lower is better)1.04 cores0.61 cores0.36 cores0.83 cores0.59 cores0.07 cores0.91 cores0.14 cores

Cost of doing nothing

With workers running and no jobs, how much does each system cost the database?

Setup. One process with 8 workers after a short warmup; 10 minutes with nothing enqueued.

  • Oban, pg-boss, Absurd and River each cost Postgres about 16–24 transactions/s when idle; PGMQ costs 160/s from its polling consumers.
  • Awa keeps 276 MB of private Postgres memory while idle, against 18–59 MB for the others: each of its connections caches metadata and prepared plans for its 220 ring tables.
Reading it
  • Background polling, heartbeats and maintenance all show up here; they are paid on every deployment, busy or not.
Transactions per second while idle
050100150200Oban16 xacts/spg-boss21.9 xacts/sAbsurd23.5 xacts/sRiver24 xacts/sPgQue40.6 xacts/sAwa60.1 xacts/sProcrastinate65.5 xacts/sPGMQ160 xacts/s
Table view
Transactions per second while idle
SystemTransactions per second while idle
Oban16 xacts/s
pg-boss21.9 xacts/s
Absurd23.5 xacts/s
River24 xacts/s
PgQue40.6 xacts/s
Awa60.1 xacts/s
Procrastinate65.5 xacts/s
PGMQ160 xacts/s
WAL written while idle
0 B/s5 KB/s10 KB/s15 KB/sPGMQ429 B/sProcrastinate459 B/sAbsurd991 B/spg-boss1.77 KB/sAwa3.91 KB/sOban4.19 KB/sPgQue7.67 KB/sRiver11.4 KB/s
Table view
WAL written while idle
SystemWAL written while idle
PGMQ429 B/s
Procrastinate459 B/s
Absurd991 B/s
pg-boss1.77 KB/s
Awa3.91 KB/s
Oban4.19 KB/s
PgQue7.67 KB/s
River11.4 KB/s
Postgres private memory while idleBackend-local memory in the Postgres container (shared buffers excluded).
0 B100 MB200 MB300 MBAbsurd17.7 MBRiver23.5 MBpg-boss24.7 MBPgQue29.1 MBProcrastinate32.7 MBPGMQ37.8 MBOban58.7 MBAwa276 MB
Table view
Postgres private memory while idle
SystemPostgres private memory while idle
Absurd17.7 MB
River23.5 MB
pg-boss24.7 MB
PgQue29.1 MB
Procrastinate32.7 MB
PGMQ37.8 MB
Oban58.7 MB
Awa276 MB
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Transactions/s (lower is better)23.5 xacts/s60.1 xacts/s16 xacts/s21.9 xacts/s160 xacts/s40.6 xacts/s65.5 xacts/s24 xacts/s
WAL written (lower is better)991 B/s3.91 KB/s4.19 KB/s1.77 KB/s429 B/s7.67 KB/s459 B/s11.4 KB/s
Table rewrites (lower is better)0 per s0.37 per s0 per s0 per s0 per s0 per s0 per s0 per s
Postgres CPU (lower is better)0.05 cores0.05 cores0.02 cores0.03 cores0.06 cores0.03 cores0.07 cores0.02 cores
Postgres private memory (lower is better)17.7 MB276 MB58.7 MB24.7 MB37.8 MB29.1 MB32.7 MB23.5 MB

PostgreSQL restart under load

When the database restarts mid-run, does the system come back and work off what accumulated?

Setup. Two processes, 400 jobs/s each, 16 workers each. 90 s baseline; Postgres stopped for 45 s and started again; 120 s recovery.

  • Every system came back to its pre-restart rate within the 5 s check after Postgres returned.
  • Absurd and Procrastinate get there only because their adapters restart the worker: both libraries stop the worker when the database goes away and expect a supervisor to start it again.
Reading it
  • Awa, Oban, pg-boss and River reconnect inside the running worker. PGMQ and PgQue are consumed by the adapters’ own loops, which reconnect.
  • Absurd's Python worker loop and Procrastinate's worker both stop when they lose the database, and expect a process supervisor (systemd, Kubernetes) to start them again. Their adapters restart the worker after 1 s, as a supervisor would. Without a supervisor, these workers stay stopped.
  • Zero after the restart means no jobs completed for the rest of the run.
Completed jobs/s after the restart
05001,000PgQue805 jobs/sAwa802 jobs/sAbsurd802 jobs/sOban802 jobs/sProcrastinate775 jobs/spg-boss668 jobs/sRiver634 jobs/sPGMQ399 jobs/s
Table view
Completed jobs/s after the restart
SystemCompleted jobs/s after the restart
PgQue805 jobs/s
Awa802 jobs/s
Absurd802 jobs/s
Oban802 jobs/s
Procrastinate775 jobs/s
pg-boss668 jobs/s
River634 jobs/s
PGMQ399 jobs/s
Queue depth after the restart
1101001,00010K100KOban0 jobsPgQue0 jobsPGMQ1 jobsProcrastinate2 jobsAwa4 jobsAbsurd6 jobspg-boss176 jobsRiver37.7K jobs

Log scale.

Table view
Queue depth after the restart
SystemQueue depth after the restart
Oban0 jobs
PgQue0 jobs
PGMQ1 jobs
Procrastinate2 jobs
Awa4 jobs
Absurd6 jobs
pg-boss176 jobs
River37.7K jobs
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Before restart (higher is better)794 jobs/s798 jobs/s793 jobs/s668 jobs/s401 jobs/s801 jobs/s777 jobs/s634 jobs/s
After restart (higher is better)802 jobs/s802 jobs/s802 jobs/s668 jobs/s399 jobs/s805 jobs/s775 jobs/s634 jobs/s
Workers back (lower is better)5.02 s5 s5.01 s5.01 s5.01 s5.01 s5 s5 s
Backlog cleared (lower is better)10 s10 s5 s–5.01 s5.01 s5 s–
End-to-end p99 after restart (lower is better)1.2 s30 ms–400 ms28 ms109 ms––
Queue depth after restart (lower is better)6 jobs4 jobs0 jobs176 jobs1 jobs0 jobs2 jobs37.7K jobs

Impact on a neighbouring application

Does a busy queue slow down unrelated transactions on the same server?

Setup. pgbench runs a TPC-B-like workload at a fixed 300 TPS on a separate database throughout. The queue runs at 0, 400, 1,600, then 400 jobs/s.

  • No system cut the neighbour's throughput (all within 1% of baseline).
  • With the queue at 4× load, the neighbour's p99 ranged from 2.4 ms (PgQue) and 5–7 ms (Procrastinate, Awa, River) to 18 ms (PGMQ).
Reading it
  • Latency is measured from each pgbench transaction's scheduled start, so it includes any queueing.
Neighbour transaction latency, p99
Queue idleQueue at 1,600 jobs/s0 ms5 ms10 ms15 ms20 msPGMQ18 msAbsurd14 msOban12 mspg-boss10 msRiver7 msAwa6 msProcrastinate5 msPgQue2 ms
Table view
Neighbour transaction latency, p99
SystemQueue idleQueue at 1,600 jobs/s
PGMQ2 ms18 ms
Absurd2 ms14 ms
Oban4 ms12 ms
pg-boss2 ms10 ms
River2 ms7 ms
Awa2 ms6 ms
Procrastinate2 ms5 ms
PgQue2 ms2 ms
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Neighbour p99, queue idle (lower is better)2 ms2 ms4 ms2 ms2 ms2 ms2 ms2 ms
Neighbour p99, queue at 1× (lower is better)6 ms4 ms5 ms5 ms5 ms3 ms5 ms9 ms
Neighbour p99, queue at 4× (lower is better)14 ms6 ms12 ms10 ms18 ms2 ms5 ms7 ms
Neighbour TPS vs idle (higher is better)1×0.99×1×1.01×1×1×1×1×
Queue jobs/s at 4× (higher is better)80 jobs/s1,600 jobs/s1,391 jobs/s512 jobs/s1,607 jobs/s1,606 jobs/s427 jobs/s317 jobs/s

Logical replication alongside the queue

Does the queue coexist with CDC on the same database, including when the CDC consumer stops?

Setup. A FOR ALL TABLES publication, a pgoutput slot and a streaming consumer; 400 jobs/s. The consumer is frozen for 4 minutes, then resumes.

  • Awa at 1a53fd9e now gives every table a replica identity (0 tables without one, down from 19 on 0.6.17) but still leaves the most dead catalog tuples while the slot is stalled (11,374, down from 19,024; the others 20–214).
  • PGMQ has 2 and PgQue 5 tables without a replica identity, so logical replication of updates and deletes on them fails.
Reading it
  • A table without a replica identity rejects UPDATE and DELETE while a FOR ALL TABLES publication exists.
  • Dead catalog tuples pile up when a system creates or truncates tables while a stalled slot holds back catalog cleanup.
Published tables without a replica identity
0246Absurd0 tablesAwa0 tablesOban0 tablespg-boss0 tablesProcrastinate0 tablesRiver0 tablesPGMQ2 tablesPgQue5 tables
Table view
Published tables without a replica identity
SystemPublished tables without a replica identity
Absurd0 tables
Awa0 tables
Oban0 tables
pg-boss0 tables
Procrastinate0 tables
River0 tables
PGMQ2 tables
PgQue5 tables
Dead catalog tuples while the consumer was stalled
101001,00010K100KPGMQ20 tuplesAbsurd22 tuplesProcrastinate25 tuplesPgQue114 tuplesOban115 tuplespg-boss139 tuplesRiver214 tuplesAwa11.4K tuples

Log scale.

Table view
Dead catalog tuples while the consumer was stalled
SystemDead catalog tuples while the consumer was stalled
PGMQ20 tuples
Absurd22 tuples
Procrastinate25 tuples
PgQue114 tuples
Oban115 tuples
pg-boss139 tuples
River214 tuples
Awa11.4K tuples
WAL retained by the stalled slot
0 B200 MB400 MB600 MBPgQue48.1 MBPGMQ169 MBAbsurd190 MBAwa201 MBpg-boss255 MBProcrastinate348 MBRiver389 MBOban569 MB
Table view
WAL retained by the stalled slot
SystemWAL retained by the stalled slot
PgQue48.1 MB
PGMQ169 MB
Absurd190 MB
Awa201 MB
pg-boss255 MB
Procrastinate348 MB
River389 MB
Oban569 MB
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Tables without replica identity (lower is better)0 tables0 tables0 tables0 tables2 tables5 tables0 tables0 tables
WAL retained by the stalled slot (lower is better)190 MB201 MB569 MB255 MB169 MB48.1 MB348 MB389 MB
Dead catalog tuples during the stall (lower is better)22 tuples11.4K tuples115 tuples139 tuples20 tuples114 tuples25 tuples214 tuples
WAL per job while streaming (lower is better)3.23 KB2.01 KB5.02 KB3.25 KB1.79 KB490 B2.87 KB4.82 KB
Jobs/s while streaming (higher is better)402 jobs/s399 jobs/s400 jobs/s334 jobs/s402 jobs/s402 jobs/s395 jobs/s317 jobs/s

A herd of scheduled jobs

When 20,000 jobs come due at the same instant, how late do they start, and do immediate jobs suffer?

Setup. 20,000 jobs scheduled for one instant while a 200 jobs/s stream of immediate jobs keeps flowing; 16 workers.

  • PGMQ starts 20,000 simultaneous scheduled jobs within 1.9 s (p99), Awa within 12 s and Oban 21 s; Procrastinate 41 s, River 63 s, pg-boss 77 s, Absurd 137 s.
  • Immediate jobs keep flowing during the herd on Awa, Oban, Procrastinate and PGMQ (p99 under 50 ms); River's, pg-boss's and Absurd's wait seconds behind it. PgQue has no per-job scheduling.
Reading it
  • PgQue has no delayed delivery and is omitted from the herd figures.
Herd lateness, p99
1 s10 s1 min10 minPGMQ1.94 sAwa12 sOban20.5 sProcrastinate41 sRiver1.04 minpg-boss1.29 minAbsurd2.28 minPgQuenot measured

Log scale.

Table view
Herd lateness, p99
SystemHerd lateness, p99
PGMQ1.94 s
Awa12 s
Oban20.5 s
Procrastinate41 s
River1.04 min
pg-boss1.29 min
Absurd2.28 min
PgQue–
Immediate jobs while the herd drains, claim p99
1 ms10 ms100 ms1 s10 s1 min10 minProcrastinate9 msOban13 msAwa19 msPGMQ43 msPgQue107 msRiver9.21 spg-boss53.1 sAbsurd1.89 min

Log scale.

Table view
Immediate jobs while the herd drains, claim p99
SystemImmediate jobs while the herd drains, claim p99
Procrastinate9 ms
Oban13 ms
Awa19 ms
PGMQ43 ms
PgQue107 ms
River9.21 s
pg-boss53.1 s
Absurd1.89 min
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Herd lateness p50 (lower is better)1.61 min6.33 s11.7 s39.3 s958 ms–20.7 s31.6 s
Herd lateness p99 (lower is better)2.28 min12 s20.5 s1.29 min1.94 s–41 s1.04 min
Herd drained (lower is better)2.29 min12.1 s20.7 s1.31 min1.95 s–41.4 s1.05 min
Immediate jobs, claim p99 (lower is better)1.89 min19 ms13 ms53.1 s43 ms107 ms9 ms9.21 s

A storm of failing jobs

When a third of jobs start failing, does useful work keep flowing?

Setup. 200 jobs/s, 16 workers. For 6 minutes 30% of new jobs fail once and 1% always fail; at most 5 attempts; each system's own backoff applies.

  • With 30% transient and 1% poison failures, every system kept completing the good jobs at the offered rate (132–138/s).
Reading it
  • Backoff policies differ by orders of magnitude between systems; that difference is part of what this measures.
Good jobs completed per second during the storm
050100150Absurd139 jobs/sPgQue138 jobs/sPGMQ138 jobs/sRiver138 jobs/sAwa138 jobs/sOban138 jobs/sProcrastinate138 jobs/spg-boss132 jobs/s
Table view
Good jobs completed per second during the storm
SystemGood jobs completed per second during the storm
Absurd139 jobs/s
PgQue138 jobs/s
PGMQ138 jobs/s
River138 jobs/s
Awa138 jobs/s
Oban138 jobs/s
Procrastinate138 jobs/s
pg-boss132 jobs/s
Claim latency during the storm, p99
10 ms100 ms1 s10 sProcrastinate11 msAbsurd12 msAwa24 msPGMQ42 msOban44 msRiver52 msPgQue107 mspg-boss8.33 s

Log scale.

Table view
Claim latency during the storm, p99
SystemClaim latency during the storm, p99
Procrastinate11 ms
Absurd12 ms
Awa24 ms
PGMQ42 ms
Oban44 ms
River52 ms
PgQue107 ms
pg-boss8.33 s
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Before the storm (higher is better)201 jobs/s200 jobs/s200 jobs/s200 jobs/s201 jobs/s201 jobs/s200 jobs/s200 jobs/s
Good jobs/s during the storm (higher is better)139 jobs/s138 jobs/s138 jobs/s132 jobs/s138 jobs/s138 jobs/s138 jobs/s138 jobs/s
Claim p99 during the storm (lower is better)12 ms24 ms44 ms8.33 s42 ms107 ms11 ms52 ms
Retry backlog cleared (lower is better)3.15 s39.4 s1.58 min9.13 s2.08 min4.08 min4.37 s–
Peak dead tuples (lower is better)7,651 tuples4,572 tuples34.6K tuples30K tuples26.9K tuples5,089 tuples31.6K tuples32.3K tuples

Many queues

What does spreading the same load over 200 queues cost, and how does each system serve many queues?

Setup. One process. 200 jobs/s in total, round-robin over 1 queue and then over 200 queues (1 job/s per queue); 16 handlers and 24 connections requested; each system uses its own idiomatic way of serving many queues, the same in both runs; 4 minutes busy, then 3 minutes idle.

  • Every system kept up with 200 jobs/s over 200 queues.
  • Idle cost at 200 queues ranges from 0.02–0.05 Postgres cores (Oban, River, Procrastinate) to about 1 core (pg-boss, PgQue) and 1.7 cores (Absurd).
Reading it
  • Awa (weighted workers), Procrastinate (one worker over every queue), PGMQ and PgQue share 16 handlers across all 200 queues.
  • River, Oban, pg-boss and Absurd need at least one worker per queue, so they run 200 at 200 queues. That is part of the result.
  • Per-queue polling and listening connections multiply with the queue count.
Claim latency, p99
1 queue200 queues1 ms10 ms100 ms1 sAbsurd255 msPgQue105 msAwa85 msRiver42 msOban13 msProcrastinate11 mspg-boss5 msPGMQ3 ms

Log scale.

Table view
Claim latency, p99
System1 queue200 queues
Absurd10 ms255 ms
PgQue137 ms105 ms
Awa19 ms85 ms
River51 ms42 ms
Oban13 ms13 ms
Procrastinate6 ms11 ms
pg-boss5 ms5 ms
PGMQ4 ms3 ms
Transactions per second once idle
1 queue200 queues05001,0001,500PgQue1,498 xacts/sAbsurd809 xacts/sAwa667 xacts/sPGMQ401 xacts/sProcrastinate374 xacts/sRiver203 xacts/sOban168 xacts/spg-boss48.9 xacts/s
Table view
Transactions per second once idle
System1 queue200 queues
PgQue35.2 xacts/s1,498 xacts/s
Absurd8.37 xacts/s809 xacts/s
Awa60.1 xacts/s667 xacts/s
PGMQ36.3 xacts/s401 xacts/s
Procrastinate374 xacts/s374 xacts/s
River7.76 xacts/s203 xacts/s
Oban163 xacts/s168 xacts/s
pg-boss16.1 xacts/s48.9 xacts/s
Postgres connections
1 queue200 queues0102030Oban25 backendsPgQue22 backendsAwa20 backendsPGMQ19 backendsAbsurd18 backendsRiver15 backendspg-boss6 backendsProcrastinate6 backends
Table view
Postgres connections
System1 queue200 queues
Oban25 backends25 backends
PgQue22 backends22 backends
Awa11 backends20 backends
PGMQ19 backends19 backends
Absurd3 backends18 backends
River5 backends15 backends
pg-boss19 backends6 backends
Procrastinate6 backends6 backends
How each system serves 200 queues
AbsurdOne client per queue (200 handler slots), sharing 16 connections; 250 ms poll (the SDK default).
AwaWeighted mode: one pool of 16 workers across every queue; one LISTEN connection.
ObanOne producer per queue with limit 1 (200 slots); idle queues don't poll.
pg-bossOne worker per queue (200); LISTEN/NOTIFY wakes idle workers.
PGMQ16 consumers sweeping their share of the queues; insert NOTIFY on one LISTEN connection; 500 ms fallback poll.
PgQueShared consumer over 16 connections; one LISTEN connection; ticker_loop every 50 ms.
ProcrastinateOne worker over all 200 queues with concurrency 16; one LISTEN connection.
RiverOne producer per queue with MaxWorkers 1 (200); River's default 100 ms cooldown and 1 s poll; one notifier connection.
All measurements in this scenario

1 queue

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)201 jobs/s200 jobs/s200 jobs/s200 jobs/s201 jobs/s200 jobs/s200 jobs/s200 jobs/s
Claim p99 (lower is better)10 ms19 ms13 ms5 ms4 ms137 ms6 ms51 ms
Postgres connections (lower is better)3 backends11 backends25 backends19 backends19 backends22 backends6 backends5 backends
LISTEN connections (lower is better)0 backends2 backends1 backends0 backends1 backends1 backends1 backends0 backends
Idle transactions/s (lower is better)8.37 xacts/s60.1 xacts/s163 xacts/s16.1 xacts/s36.3 xacts/s35.2 xacts/s374 xacts/s7.76 xacts/s
Idle Postgres CPU (lower is better)0.02 cores0.06 cores0.02 cores0.05 cores0.03 cores0.03 cores0.03 cores0.02 cores

200 queues

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)201 jobs/s200 jobs/s200 jobs/s200 jobs/s201 jobs/s200 jobs/s200 jobs/s200 jobs/s
Claim p99 (lower is better)255 ms85 ms13 ms5 ms3 ms105 ms11 ms42 ms
Postgres connections (lower is better)18 backends20 backends25 backends6 backends19 backends22 backends6 backends15 backends
LISTEN connections (lower is better)0 backends2 backends1 backends0 backends1 backends1 backends1 backends0 backends
Idle transactions/s (lower is better)809 xacts/s667 xacts/s168 xacts/s48.9 xacts/s401 xacts/s1,498 xacts/s374 xacts/s203 xacts/s
Idle Postgres CPU (lower is better)1.68 cores0.24 cores0.02 cores0.98 cores0.11 cores1.05 cores0.04 cores0.05 cores

Large job arguments

What happens with 64 KiB and 1 MiB arguments, and does the database shrink back afterwards?

Setup. Incompressible arguments. Saturation: one process, 64 workers, 2,000 jobs queued, 120 s. Backlog: about 8 GiB of 1 MiB jobs preloaded by four processes, then drained by 4 × 16 workers.

  • After draining an 8 GiB backlog of 1 MiB jobs, Awa's database is back to 21 MB; every other system keeps 7–8 GB (PGMQ 16 GB, archive included).
  • Worker memory while draining 1 MiB jobs: Oban 8.7 GB and pg-boss 5.3 GB, against 0.2–1 GB for the others.
Reading it
  • The saturation cells are bound by one producer connection, so they compare insert paths as much as workers.
  • PostgreSQL keeps a table's disk space after its rows are deleted; only systems that truncate or drop storage give it back without VACUUM FULL.
1 MiB args: MiB/s completed
0204060River51.2 MiB/sAwa51.2 MiB/sOban44.9 MiB/sAbsurd38.4 MiB/spg-boss25.6 MiB/sPGMQ25.6 MiB/sPgQue25.4 MiB/sProcrastinate22 MiB/s
Table view
1 MiB args: MiB/s completed
System1 MiB args: MiB/s completed
River51.2 MiB/s
Awa51.2 MiB/s
Oban44.9 MiB/s
Absurd38.4 MiB/s
pg-boss25.6 MiB/s
PGMQ25.6 MiB/s
PgQue25.4 MiB/s
Procrastinate22 MiB/s
64 KiB args: MiB/s completed
0204060River49.9 MiB/sAwa43.2 MiB/sOban41.5 MiB/spg-boss35.2 MiB/sPGMQ26.5 MiB/sPgQue23.9 MiB/sAbsurd16.8 MiB/sProcrastinate12.4 MiB/s
Table view
64 KiB args: MiB/s completed
System64 KiB args: MiB/s completed
River49.9 MiB/s
Awa43.2 MiB/s
Oban41.5 MiB/s
pg-boss35.2 MiB/s
PGMQ26.5 MiB/s
PgQue23.9 MiB/s
Absurd16.8 MiB/s
Procrastinate12.4 MiB/s
Database size after draining the 1 MiB backlog
10 MB100 MB1 GB10 GB100 GBAwa21.3 MBProcrastinate7.35 GBRiver8 GBOban8 GBAbsurd8 GBPgQue8.33 GBpg-boss8.35 GBPGMQ16 GB

Log scale.

Table view
Database size after draining the 1 MiB backlog
SystemDatabase size after draining the 1 MiB backlog
Awa21.3 MB
Procrastinate7.35 GB
River8 GB
Oban8 GB
Absurd8 GB
PgQue8.33 GB
pg-boss8.35 GB
PGMQ16 GB
Worker memory while draining, all four processes
100 MB1 GB10 GBProcrastinate216 MBPgQue217 MBAwa259 MBAbsurd366 MBRiver379 MBPGMQ998 MBpg-boss5.32 GBOban8.71 GB

Log scale.

Table view
Worker memory while draining, all four processes
SystemWorker memory while draining, all four processes
Procrastinate216 MB
PgQue217 MB
Awa259 MB
Absurd366 MB
River379 MB
PGMQ998 MB
pg-boss5.32 GB
Oban8.71 GB
All measurements in this scenario

64 KiB args, saturating

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)269 jobs/s691 jobs/s664 jobs/s563 jobs/s424 jobs/s383 jobs/s199 jobs/s798 jobs/s
WAL per job (lower is better)113 KB94.8 KB103 KB73.6 KB188 KB71 KB110 KB86.5 KB
Worker memory, peak (lower is better)59.8 MB88 MB2.26 GB366 MB233 MB98.8 MB40.6 MB52.9 MB
Database, peak (lower is better)3.31 GB1.69 GB9.92 GB6.37 GB24.7 GB3.9 GB1.89 GB12 GB
Database after the drain (lower is better)3.31 GB1.22 GB9.92 GB6.37 GB24.7 GB3.9 GB1.89 GB12 GB

1 MiB args, saturating

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)38.4 jobs/s51.2 jobs/s44.9 jobs/s25.6 jobs/s25.6 jobs/s25.4 jobs/s22 jobs/s51.2 jobs/s
WAL per job (lower is better)1.27 MB1.42 MB1.2 MB1.49 MB3.62 MB1.12 MB1.96 MB1.24 MB
Worker memory, peak (lower is better)372 MB944 MB2.55 GB552 MB3.08 GB808 MB57.1 MB531 MB
Database, peak (lower is better)15.9 GB1.63 GB10.3 GB7.25 GB17 GB4.05 GB3.44 GB19.6 GB
Database after the drain (lower is better)15.9 GB823 MB10.3 GB7.25 GB17 GB4.05 GB3.44 GB19.6 GB

1 MiB backlog, drained

MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Jobs preloaded (higher is better)7,684 jobs6,494 jobs7,675 jobs8,004 jobs7,684 jobs7,994 jobs7,056 jobs7,680 jobs
Drain rate (higher is better)243 jobs/s170 jobs/s258 jobs/s616 jobs/s45.2 jobs/s231 jobs/s184 jobs/s279 jobs/s
Worker memory while draining (lower is better)366 MB259 MB8.71 GB5.32 GB998 MB217 MB216 MB379 MB
Database, peak (lower is better)8 GB6.77 GB8 GB8.35 GB16 GB8.33 GB7.35 GB8 GB
Database after the drain (lower is better)8 GB21.3 MB8 GB8.35 GB16 GB8.33 GB7.35 GB8 GB

Moderate payloads over time

At a gentle rate with 64 KiB arguments, how much WAL is written and how much space is left behind?

Setup. 64 KiB incompressible arguments at 50 jobs/s for 5 minutes, then 3 minutes of draining.

  • Only Awa gives the space back: 22 MB after the run, where every other system keeps about 1.2 GB of TOAST until VACUUM FULL.
  • PGMQ writes about 2.5× the WAL per 64 KiB job of the others (205 KB), because acknowledging archives the message.
TOAST storage after draining
100 KB1 MB10 MB100 MB1 GB10 GBAwa625 KBProcrastinate1.16 GBOban1.17 GBRiver1.17 GBAbsurd1.17 GBpg-boss1.17 GBPGMQ1.18 GBPgQue1.18 GB

Log scale.

Table view
TOAST storage after draining
SystemTOAST storage after draining
Awa625 KB
Procrastinate1.16 GB
Oban1.17 GB
River1.17 GB
Absurd1.17 GB
pg-boss1.17 GB
PGMQ1.18 GB
PgQue1.18 GB
WAL written per job
0 B100 KB200 KB300 KBPgQue70.9 KBAwa75.3 KBProcrastinate80.7 KBRiver81 KBOban83.1 KBpg-boss84.2 KBAbsurd86.7 KBPGMQ205 KB
Table view
WAL written per job
SystemWAL written per job
PgQue70.9 KB
Awa75.3 KB
Procrastinate80.7 KB
River81 KB
Oban83.1 KB
pg-boss84.2 KB
Absurd86.7 KB
PGMQ205 KB
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Completed jobs/s (higher is better)50 jobs/s50 jobs/s50 jobs/s50 jobs/s50 jobs/s50.1 jobs/s49.8 jobs/s50 jobs/s
WAL per job (lower is better)86.7 KB75.3 KB83.1 KB84.2 KB205 KB70.9 KB80.7 KB81 KB
TOAST after draining (lower is better)1.17 GB625 KB1.17 GB1.17 GB1.18 GB1.18 GB1.16 GB1.17 GB
Database after draining (lower is better)1.19 GB22.2 MB1.19 GB1.19 GB1.19 GB1.19 GB1.18 GB1.19 GB

Long-running jobs

What does it cost to keep jobs running for 40 seconds each?

Setup. Two processes × 100 workers; 40 s jobs; 150 held, then a steady stream for 6 minutes.

  • Keeping 40 s jobs running costs between 4.6 KB/s of WAL (PGMQ) and 28 KB/s (Awa, whose lease heartbeats write more often).
  • Absurd (1,134), PGMQ (610), River (360) and Oban (298) ran some 40 s jobs more than once in this cell.
Reading it
  • Heartbeats and lease extensions are writes. A timeout shorter than the job causes duplicate execution.
WAL written per second at steady state
0 B/s10 KB/s20 KB/s30 KB/sPGMQ4.64 KB/sProcrastinate5.95 KB/sPgQue6.26 KB/spg-boss6.52 KB/sOban11.2 KB/sRiver11.5 KB/sAbsurd12.3 KB/sAwa27.9 KB/s
Table view
WAL written per second at steady state
SystemWAL written per second at steady state
PGMQ4.64 KB/s
Procrastinate5.95 KB/s
PgQue6.26 KB/s
pg-boss6.52 KB/s
Oban11.2 KB/s
River11.5 KB/s
Absurd12.3 KB/s
Awa27.9 KB/s
Duplicate completions
05001,0001,500PgQue-842 jobspg-boss0 jobsProcrastinate0.0021 jobsAwa0.0057 jobsOban298 jobsRiver360 jobsPGMQ610 jobsAbsurd1,134 jobs
Table view
Duplicate completions
SystemDuplicate completions
PgQue-842 jobs
pg-boss0 jobs
Procrastinate0.0021 jobs
Awa0.0057 jobs
Oban298 jobs
River360 jobs
PGMQ610 jobs
Absurd1,134 jobs
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
WAL written (lower is better)12.3 KB/s27.9 KB/s11.2 KB/s6.52 KB/s4.64 KB/s6.26 KB/s5.95 KB/s11.5 KB/s
Transactions/s (lower is better)14.4 xacts/s115 xacts/s15.9 xacts/s260 xacts/s244 xacts/s47 xacts/s103 xacts/s52.3 xacts/s
Rows updated/s (lower is better)17 rows/s24.2 rows/s5.51 rows/s4.82 rows/s5.89 rows/s0.72 rows/s4.47 rows/s6.13 rows/s
Duplicate completions (lower is better)1,134 jobs0.0057 jobs298 jobs0 jobs610 jobs-842 jobs0.0021 jobs360 jobs

Draining a backlog

How fast does a 200,000-job backlog drain, and how big is the database afterwards?

Setup. 200,000 jobs preloaded behind a gate, then drained by 64 workers, then 4 minutes idle.

  • PGMQ and PgQue drain a 200,000-job backlog at about 14,500 jobs/s; Awa at 5,154/s, Oban 4,206/s, pg-boss 2,510/s, River 1,226/s, Procrastinate 579/s; Absurd did not finish in 6 minutes.
  • Only Awa's database shrinks back afterwards (21 MB).
Drain rate
05,00010K15KPGMQ14.5K jobs/sPgQue14.3K jobs/sAwa5,154 jobs/sOban4,206 jobs/spg-boss2,510 jobs/sRiver1,226 jobs/sProcrastinate579 jobs/sAbsurdnot measured
Table view
Drain rate
SystemDrain rate
PGMQ14.5K jobs/s
PgQue14.3K jobs/s
Awa5,154 jobs/s
Oban4,206 jobs/s
pg-boss2,510 jobs/s
River1,226 jobs/s
Procrastinate579 jobs/s
Absurd–
Database size after draining
10 MB100 MB1 GBAwa21.5 MBPgQue75.9 MBProcrastinate92.1 MBPGMQ97.3 MBpg-boss205 MBAbsurd211 MBRiver216 MBOban323 MB

Log scale.

Table view
Database size after draining
SystemDatabase size after draining
Awa21.5 MB
PgQue75.9 MB
Procrastinate92.1 MB
PGMQ97.3 MB
pg-boss205 MB
Absurd211 MB
River216 MB
Oban323 MB
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Drain rate (higher is better)–5,154 jobs/s4,206 jobs/s2,510 jobs/s14.5K jobs/s14.3K jobs/s579 jobs/s1,226 jobs/s
Time to empty (lower is better)–38.8 s47.3 s1.2 min13.8 s14 s3.97 min2.72 min
Database before (lower is better)7.83 MB20.7 MB7.81 MB8.43 MB7.86 MB8.7 MB7.81 MB7.94 MB
Database, peak (lower is better)211 MB173 MB323 MB205 MB179 MB75.9 MB92.1 MB216 MB
Database after (lower is better)211 MB21.5 MB323 MB205 MB97.3 MB75.9 MB92.1 MB216 MB
Back to baseline size (lower is better)–1.22 min––––––

Finding one job among a million

With a million jobs queued, how long does an operator wait to find one?

Setup. A million jobs sit in a queue no worker consumes, each tagged with a unique handle and one of 1,000 tenants, while 200 jobs/s of ordinary work runs on another queue. Each probe runs through the system's own API (or SQL where that is the interface) at 2 per second for 3 minutes, on its own connection.

  • Getting one job by id is fast everywhere it's possible: under 2 ms at p99 for Absurd, Oban, pg-boss, Procrastinate, River and PGMQ, and 103 ms for Awa 0.6, whose get_job checks each of its storage locations. PgQue can't look up an event.
  • Finding one job by a unique field: River 2.4 ms at p50 (GIN on metadata); Absurd 73 ms, PGMQ 144 ms, Oban 188 ms and pg-boss 192 ms, which scan. Awa 0.6 timed out at 30 s every time (tags are checked after loading, with no index); Procrastinate and PgQue can't filter on job data.
  • A first page by kind and state is quick for PGMQ, pg-boss, River and Oban (1–3 ms at p50); Absurd takes 107 ms, Procrastinate 405 ms (it returns all 50,000 matches, with no LIMIT) and Awa 0.6 1.4 s.
  • Procrastinate's ordinary work stalled behind the haystack: with a million jobs queued in another queue, its worker's fetch had to scan past them, and the bench queue fell to 10–18 jobs/s with a pickup p99 of 91–200 s. Probing didn't hurt any other system's live load.
  • Awa 0.7 (unreleased) answers every probe, including the tag filters that time out on 0.6, but each takes 0.5–1.2 s. Two queries in the unreleased build are responsible: a job lookup that hash-joins every ready row, and a queue count that walks every available job. Both are being fixed before release.
Reading it
  • The label after each bar says how the answer was obtained: no label is the system's API; SQL means a raw query against its tables; not supported means the system offers no way to ask.
  • Where a filter has no index behind it, the probe scans the million jobs; that shows up as seconds rather than milliseconds.
Get one job by id, p99
1 ms10 ms100 ms1 sRiver0.85 msPGMQ0.88 ms · SQLOban1 msAbsurd1 msProcrastinate2 mspg-boss2 msAwa103 msAwa 0.7 (unreleased)551 msPgQuenot supported

Log scale.

Table view
Get one job by id, p99
SystemGet one job by id, p99
River0.85 ms
PGMQ0.88 ms (SQL)
Oban1 ms
Absurd1 ms
Procrastinate2 ms
pg-boss2 ms
Awa103 ms
Awa 0.7 (unreleased)551 ms
PgQue– (not supported)
Find one job by a unique field, p99
10 ms100 ms1 s10 s1 minAbsurd80 ms · SQLPGMQ164 ms · SQLpg-boss205 msOban206 msRiver290 msAwa 0.7 (unreleased)588 msAwa30 s · timed out (30 s cap)PgQuenot supportedProcrastinatenot supported

Log scale.

Table view
Find one job by a unique field, p99
SystemFind one job by a unique field, p99
Absurd80 ms (SQL)
PGMQ164 ms (SQL)
pg-boss205 ms
Oban206 ms
River290 ms
Awa 0.7 (unreleased)588 ms
Awa30 s (timed out (30 s cap))
PgQue– (not supported)
Procrastinate– (not supported)
First page of one tenant's 1,000 jobs, p99
10 ms100 ms1 s10 s1 minOban28 msRiver29 msPGMQ60 ms · SQLpg-boss70 msAbsurd93 ms · SQLAwa 0.7 (unreleased)665 msAwa30 s · timed out (30 s cap)PgQuenot supportedProcrastinatenot supported

Log scale.

Table view
First page of one tenant's 1,000 jobs, p99
SystemFirst page of one tenant's 1,000 jobs, p99
Oban28 ms
River29 ms
PGMQ60 ms (SQL)
pg-boss70 ms
Absurd93 ms (SQL)
Awa 0.7 (unreleased)665 ms
Awa30 s (timed out (30 s cap))
PgQue– (not supported)
Procrastinate– (not supported)
First page by kind and state, p99
1 ms10 ms100 ms1 s10 sPGMQ2 ms · SQLpg-boss3 msRiver4 msOban4 msAbsurd126 ms · SQLProcrastinate433 msAwa 0.7 (unreleased)903 msAwa2.4 sPgQuenot supported

Log scale.

Table view
First page by kind and state, p99
SystemFirst page by kind and state, p99
PGMQ2 ms (SQL)
pg-boss3 ms
River4 ms
Oban4 ms
Absurd126 ms (SQL)
Procrastinate433 ms
Awa 0.7 (unreleased)903 ms
Awa2.4 s
PgQue– (not supported)
Count by state, p99
1 ms10 ms100 ms1 s10 sPgQue0.94 mspg-boss1 msPGMQ48 msAbsurd58 ms · SQLRiver138 ms · SQLOban147 msAwa149 msProcrastinate655 msAwa 0.7 (unreleased)1.19 s

Log scale.

Table view
Count by state, p99
SystemCount by state, p99
PgQue0.94 ms
pg-boss1 ms
PGMQ48 ms
Absurd58 ms (SQL)
River138 ms (SQL)
Oban147 ms
Awa149 ms
Procrastinate655 ms
Awa 0.7 (unreleased)1.19 s
How each system finds a job
Absurdget_by_id through the SDK (fetch_task_result); the filters and count are the SQL its absurdctl list-tasks builds, against its task tables.
Awa0.6: get_job, list_jobs (tag, kind, state, queue; tags are checked after loading, with no index), queue_overview for counts. 0.7: find_jobs with a per-partition GIN index on tags.
ObanOban.Job.query (id, args containment, worker, state, queue) through the Repo; GIN index on args.
pg-bossfindJobs by id or data within one queue; getQueue counts are cached by the monitor (refreshed every 60 s).
PGMQSQL on the queue table, which is pgmq's interface (by msg_id, message containment); pgmq.metrics for the count.
PgQueCounts only (get_queue_info); events can't be looked up.
Procrastinatelist_jobs by id, queue, task and status, with no LIMIT and no filter on arguments; list_queues for counts.
RiverJobGet and JobList (metadata containment, kind, state, queue) with a GIN index on metadata; counts by SQL (no count API).
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiverAwa 0.7 (unreleased)
Time to enqueue the haystack (lower is better)2.23 min34.6 s1.21 min49.9 s13.3 s11.5 s1.51 min29.8 s46.9 s
Get by id, p50 (lower is better)0.76 ms10 ms0.36 ms1 ms0.32 ms–0.96 ms0.27 ms471 ms
Get by id, p99 (lower is better)1 ms103 ms1 ms2 ms0.88 ms–2 ms0.85 ms551 ms
Get by id: API (higher is better)1 mode1 mode1 mode1 mode2 mode0 mode1 mode1 mode1 mode
Get by id: correct answers (higher is better)1 fraction1 fraction1 fraction1 fraction1 fraction–1 fraction1 fraction1 fraction
Find one job by a unique field, p50 (lower is better)73 ms30 s188 ms192 ms144 ms––2 ms510 ms
Find one job by a unique field, p99 (lower is better)80 ms30 s206 ms205 ms164 ms––290 ms588 ms
Find one job by a unique field: API (higher is better)2 mode1 mode1 mode1 mode2 mode0 mode0 mode1 mode1 mode
Find one job by a unique field: correct answers (higher is better)1 fraction0 fraction1 fraction1 fraction1 fraction––1 fraction1 fraction
First page for one tenant, p50 (lower is better)76 ms30 s15 ms65 ms20 ms––13 ms533 ms
First page for one tenant, p99 (lower is better)93 ms30 s28 ms70 ms60 ms––29 ms665 ms
First page for one tenant: API (higher is better)2 mode1 mode1 mode1 mode2 mode0 mode0 mode1 mode1 mode
First page for one tenant: correct answers (higher is better)1 fraction0 fraction1 fraction1 fraction1 fraction––1 fraction1 fraction
First page by kind and state, p50 (lower is better)107 ms1.41 s3 ms2 ms0.92 ms–405 ms3 ms721 ms
First page by kind and state, p99 (lower is better)126 ms2.4 s4 ms3 ms2 ms–433 ms4 ms903 ms
First page by kind and state: API (higher is better)2 mode1 mode1 mode1 mode2 mode0 mode1 mode1 mode1 mode
First page by kind and state: correct answers (higher is better)1 fraction1 fraction1 fraction1 fraction1 fraction–1 fraction1 fraction1 fraction
Count by state, p50 (lower is better)51 ms56 ms120 ms1 ms38 ms0.53 ms431 ms125 ms1.04 s
Count by state, p99 (lower is better)58 ms149 ms147 ms1 ms48 ms0.94 ms655 ms138 ms1.19 s
Count by state: API (higher is better)2 mode1 mode1 mode1 mode1 mode1 mode1 mode2 mode1 mode
Count by state: correct answers (higher is better)1 fraction1 fraction1 fraction1 fraction1 fraction1 fraction1 fraction1 fraction1 fraction
Claim p99, ordinary load (lower is better)63 ms45 ms14 ms474 ms46 ms107 ms1.51 min112 ms29 ms
Claim p99 while probing (lower is better)17 ms13 ms13 ms236 ms43 ms107 ms3.34 min52 ms19 ms
Jobs/s while probing (higher is better)204 jobs/s201 jobs/s199 jobs/s200 jobs/s204 jobs/s203 jobs/s9.98 jobs/s202 jobs/s201 jobs/s

Pausing and resuming a queue

When an operator pauses a busy queue, does work stop everywhere, and how fast does it come back?

Setup. Two worker processes at 200 jobs/s each. The bench queue is paused; while paused, one process is restarted; then the queue is resumed. Systems without a pause stop each process's workers locally (labelled emulated), which a restarted process doesn't know about.

  • Awa, River and PgQue store the pause in the database: no job started while paused, including on the process restarted mid-pause, and work resumed within 28–153 ms.
  • Oban (open source) holds the pause in memory on the running nodes: the restarted node came up unpaused and started 21,435 jobs while the queue was meant to be paused.
  • Absurd, pg-boss, Procrastinate and PGMQ have no pause; stopping each process's workers is the only option, and the restarted process worked through the backlog (7,680–21,014 jobs).
Reading it
  • A pause stored in the database survives a restarted process; one held in memory, or a per-process stop, does not, so the restarted process starts working again while the queue should be paused.
Jobs started while pausedIncluding the process restarted mid-pause.
010K20K30KAwa0 jobsPgQue0 jobsRiver0 jobsAwa 0.7 (unreleased)0 jobspg-boss7,680 jobs · emulated: each process stopsAbsurd11.6K jobs · emulated: each process stopsProcrastinate16.2K jobs · emulated: each process stopsPGMQ21K jobs · emulated: each process stopsOban21.4K jobs
Table view
Jobs started while paused
SystemJobs started while paused
Awa0 jobs
PgQue0 jobs
River0 jobs
Awa 0.7 (unreleased)0 jobs
pg-boss7,680 jobs (emulated: each process stops)
Absurd11.6K jobs (emulated: each process stops)
Procrastinate16.2K jobs (emulated: each process stops)
PGMQ21K jobs (emulated: each process stops)
Oban21.4K jobs
Last job start after the pause returned
10 s1 minAwa0 msPgQue0 msRiver0 msAwa 0.7 (unreleased)0 mspg-boss54.9 s · emulated: each process stopsProcrastinate55 s · emulated: each process stopsAbsurd55.5 s · emulated: each process stopsPGMQ55.5 s · emulated: each process stopsOban58 s

Log scale.

Table view
Last job start after the pause returned
SystemLast job start after the pause returned
Awa0 ms
PgQue0 ms
River0 ms
Awa 0.7 (unreleased)0 ms
pg-boss54.9 s (emulated: each process stops)
Procrastinate55 s (emulated: each process stops)
Absurd55.5 s (emulated: each process stops)
PGMQ55.5 s (emulated: each process stops)
Oban58 s
First job start after the resume
1 ms10 ms100 ms1 spg-boss3 ms · emulated: each process stopsProcrastinate8 ms · emulated: each process stopsOban16 msAbsurd23 ms · emulated: each process stopsAwa28 msRiver28 msAwa 0.7 (unreleased)37 msPGMQ53 ms · emulated: each process stopsPgQue153 ms

Log scale.

Table view
First job start after the resume
SystemFirst job start after the resume
pg-boss3 ms (emulated: each process stops)
Procrastinate8 ms (emulated: each process stops)
Oban16 ms
Absurd23 ms (emulated: each process stops)
Awa28 ms
River28 ms
Awa 0.7 (unreleased)37 ms
PGMQ53 ms (emulated: each process stops)
PgQue153 ms
Back to 90% of the earlier rate
0 ms500 ms1 s1.5 sProcrastinate66 ms · emulated: each process stopsOban174 msPGMQ220 ms · emulated: each process stopsAbsurd393 ms · emulated: each process stopsAwa611 mspg-boss710 ms · emulated: each process stopsRiver777 msPgQue1.02 sAwa 0.7 (unreleased)1.31 s
Table view
Back to 90% of the earlier rate
SystemBack to 90% of the earlier rate
Procrastinate66 ms (emulated: each process stops)
Oban174 ms
PGMQ220 ms (emulated: each process stops)
Absurd393 ms (emulated: each process stops)
Awa611 ms
pg-boss710 ms (emulated: each process stops)
River777 ms
PgQue1.02 s
Awa 0.7 (unreleased)1.31 s
How each system pauses a queue
AbsurdNo pause; emulated by stopping each process's worker.
Awapause_queue / resume_queue, stored in the database and checked on every claim.
Obanpause_queue / resume_queue, broadcast to running nodes and held in memory (open source); a restarted node starts unpaused.
pg-bossNo pause; emulated with offWork / work in each process.
PGMQNo pause; emulated by stopping each process's readers.
PgQueticker_paused queue setting, stored in the database; batches already ticked are still delivered.
ProcrastinateNo pause; emulated by stopping and restarting each process's worker.
RiverQueuePause / QueueResume, stored in the database and signalled by NOTIFY.
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiverAwa 0.7 (unreleased)
Pause: API (higher is better)3 mode1 mode1 mode3 mode3 mode1 mode3 mode1 mode1 mode
Pause call (lower is better)0 ms2 ms0.42 ms0 ms0 ms4 ms132 ms9 ms2 ms
Last job start after the pause (lower is better)55.5 s0 ms58 s54.9 s55.5 s0 ms55 s0 ms0 ms
Jobs started while paused (incl. a restarted process) (lower is better)11.6K jobs0 jobs21.4K jobs7,680 jobs21K jobs0 jobs16.2K jobs0 jobs0 jobs
Resume call (lower is better)0 ms1 ms0.36 ms0 ms0 ms4 ms0.0048 ms1 ms2 ms
First job start after the resume (lower is better)23 ms28 ms16 ms3 ms53 ms153 ms8 ms28 ms37 ms
Back to 90% of the earlier rate (lower is better)393 ms611 ms174 ms710 ms220 ms1.02 s66 ms777 ms1.31 s

A million abandoned claims

When an entire fleet dies holding about a million claimed jobs, how long until those jobs have run?

Setup. Four processes preload 1,000,000 jobs and claim them all while their handlers hold instead of running. All four are killed at once (SIGKILL); a fresh fleet of 4 × 128 workers starts, with 80 new jobs/s arriving. Every claim timeout is 300 s.

  • PgQue redelivers abandoned batches at once (16 s); among per-job systems PGMQ finishes in 5.9 min, pg-boss 14 min, Awa 20.5 min, Absurd 28.5 min and Procrastinate 32 min.
  • Oban's Lifeline rescued about a fifth of the jobs in 30 minutes (798,438 still unfinished).
  • Apart from Oban's unfinished jobs, none went missing; a few ran twice (Absurd 43, pg-boss 80, PGMQ 102, PgQue 12).
Reading it
  • Timeout-based systems cannot release a claim before its timeout, which has to exceed the longest job; the first rescue is mostly configuration. The rate after that is the system.
  • PgQue is a different contract, not a faster rescue. A consumer's claim is one open batch (here about 200,000 events each). The restarted consumer gets the same batch back at once, reads it in one query, runs the handlers and acknowledges the whole batch with one statement. The job frameworks write a state change for every one of the million jobs.
  • The completion curves include working the jobs off again, so the fresh fleet's speed bounds them.
  • River held no claims to abandon: with 250,000 workers per process its fetches (up to 5,500 jobs per queue) hit River's 10 s fetch timeout on the million-job table, so this setup measures nothing for River.
Abandoned jobs completed again% of the abandoned jobs completed, by minutes since the fleet was killed.

Absurdall done after 28.5 min

0%100%0 min20 min40 min

Awaall done after 20.5 min

0%100%0 min20 min40 min

Oban20% done at 36 min

0%100%0 min20 min40 min

pg-bossall done after 14 min

0%100%0 min20 min40 min

PGMQall done after 5.88 min

0%100%0 min20 min40 min

PgQueall done after 16.3 s

0%100%0 min20 min40 min

Procrastinateall done after 32 min

0%100%0 min20 min40 min
Table view
Abandoned jobs completed again
SystemSummary
Absurdall done after 28.5 min
Awaall done after 20.5 min
Oban20% done at 36 min
pg-bossall done after 14 min
PGMQall done after 5.88 min
PgQueall done after 16.3 s
Procrastinateall done after 32 min
Time until every abandoned job had completed
0 ms10 min20 min30 min40 minPgQue16.3 sPGMQ5.88 minpg-boss14 minAwa20.5 minAbsurd28.5 minProcrastinate32 minObannot all done in 30 minRiverheld no claims at the kill
Table view
Time until every abandoned job had completed
SystemTime until every abandoned job had completed
PgQue16.3 s
PGMQ5.88 min
pg-boss14 min
Awa20.5 min
Absurd28.5 min
Procrastinate32 min
Oban– (not all done in 30 min)
River– (held no claims at the kill)
Time until the database released the dead fleet's claims
0 ms10 min20 min30 min40 minPgQue26 sPGMQ3.63 minpg-boss14.3 minAwa22.2 minAbsurd25.6 minProcrastinate32.1 minObannot measuredRiverheld no claims at the kill
Table view
Time until the database released the dead fleet's claims
SystemTime until the database released the dead fleet's claims
PgQue26 s
PGMQ3.63 min
pg-boss14.3 min
Awa22.2 min
Absurd25.6 min
Procrastinate32.1 min
Oban–
River– (held no claims at the kill)
All measurements in this scenario
MeasurementAbsurdAwaObanpg-bossPGMQPgQueProcrastinateRiver
Claims held at the kill (higher is better)998K jobs1.00e+3K jobs998K jobs1.1M jobs999K jobs1.00e+3K jobs911K jobs–
First 1% done again (lower is better)2.19 min2.34 min2.12 min5.63 s2.05 min11.3 s5.27 min–
50% done again (lower is better)11.9 min12.3 min–6.43 min3.71 min11.3 s19 min–
All done again (lower is better)28.5 min20.5 min–14 min5.88 min16.3 s32 min–
Database claims cleared (lower is better)25.6 min22.2 min–14.3 min3.63 min26 s32.1 min–
Rescue rate, 10–90% (higher is better)593 jobs/s919 jobs/s–1,533 jobs/s4,436 jobs/s–558 jobs/s–
Never completed (lower is better)0 jobs0 jobs798K jobs0 jobs0 jobs0 jobs0 jobs–
Completed twice (lower is better)43 jobs0 jobs0 jobs80 jobs102 jobs12 jobs0 jobs–
Fresh jobs, claim p99 during rescue (lower is better)1.65 min117 ms2.47 s43 ms36 ms106 ms32 ms–
Postgres CPU during rescue (lower is better)3.39 cores3.89 cores1.87 cores2.88 cores1.3 cores0.16 cores1.89 cores–

How the runs work

Measure the contract you need.

A common database does not create a common benchmark. Each system is driven through its public API by an adapter in this repository, with the same harness, workload and database.

01

Start with steady state.

Choose handler work, payload, offered load, pool budget and concurrency. Warm up before sampling; measure completion rate and end-to-end latency together with backlog.

02

Push past equilibrium.

Overload the producer, then reduce the load. Observe queue growth, recovery and whether retries consume capacity intended for useful work.

03

Make PostgreSQL uncomfortable.

Hold an old snapshot, introduce long transactions and watch vacuum, WAL and lock waits. A short clean-throughput cell misses those costs.

04

Break the process.

Kill a worker, interrupt a database connection, and restart PostgreSQL in a controlled environment. Account for work and external effects, rather than only observing a returning rate.

Adapters already in this repository

Presence is coverage, not an endorsement or a guarantee that the adapter pin equals the current documentation snapshot.

Six profiles are documentation-only.

PotatoQ, Graphile Worker, GoodJob, Que, Solid Queue and original PgQ are not presented as measured adapters. Adding them requires a version-pinned adapter and a comparable, fully specified run.

Keep the environment together.

Record the database/image, host allocation, system and SDK commits, batch sizes, connections, workload and test duration. Do not combine different environments or per-system best cases into one ranking.

Account for the contract.

A per-job completion, visibility-timeout acknowledgement and whole-batch event acknowledgement have different costs. Workflow checkpointing adds another boundary. Test the mechanism you will deploy.

Keep gaps visible.

Missing samples stay missing. Repeat runs, preserve failures, distinguish metric sampling from independent trials, and audit reconnect/shutdown behavior before attributing an adapter result to the entire product.