Skip to content
Deedboxlatest

Benchmarks

This page shows how fast appends are, and where the ceiling is. The nightly workflow runs the benchmarks and reports each cell against the baseline.

Run them yourself with just bench.

Deedbox benchmarks

Append throughput and latency across the matrix: writers × events per append × provider × mode. Each cell runs 2 s of warm-up, then 8 s of measurement. Each writer appends to its own stream, so the position counter is the only point of contention. Counter p50 and p99 are the time from the counter update, including any wait for its lock, to the end of the append.

  • Run: the nightly workflow of 2026-10-19, GitHub-hosted ubuntu-latest runner, Postgres 17 and SQL Server 2022 in Docker on the same machine: https://github.com/alternayte/deedbox/actions/runs/39224756475.
  • Commit: 0a704c0, which holds the 0.8.0 code.
  • Modes: neither means Deedbox opens and commits the transaction; efcore means UseDbContext with one inline EF Core projection.
Provider Mode Writers Events per append Appends/s Events/s p50 ms p99 ms Counter p50 ms Counter p99 ms
postgres neither 1 1 655 655 1.52 1.92 0.84 1.08
postgres neither 8 1 1142 1142 5.44 24.72 4.56 23.82
postgres neither 32 1 1006 1006 20.75 155.61 19.93 154.60
postgres neither 128 1 744 744 115.63 767.57 114.48 766.67
postgres neither 1 10 618 6178 1.61 2.01 0.92 1.16
postgres neither 8 10 1003 10029 5.65 31.15 4.77 30.31
postgres neither 32 10 878 8784 21.67 191.96 20.68 190.98
postgres neither 128 10 659 6590 131.91 921.73 130.85 920.52
postgres efcore 1 1 326 326 3.02 3.90 0.88 1.16
postgres efcore 8 1 823 823 9.03 21.29 5.10 17.43
postgres efcore 32 1 713 713 29.35 212.64 25.41 207.91
postgres efcore 128 1 536 536 160.46 1133.37 156.68 1128.74
postgres efcore 1 10 296 2957 3.35 4.21 1.04 1.30
postgres efcore 8 10 725 7254 10.26 23.78 5.69 19.13
postgres efcore 32 10 648 6484 31.69 237.51 27.24 233.01
postgres efcore 128 10 518 5180 167.19 1116.63 162.23 1112.98
sqlserver neither 1 1 471 471 2.08 2.80 1.17 1.63
sqlserver neither 8 1 820 820 8.73 56.52 7.67 55.45
sqlserver neither 32 1 872 872 36.38 41.63 35.29 40.59
sqlserver neither 128 1 762 762 118.40 371.06 117.02 366.84
sqlserver neither 1 10 407 4074 2.34 4.28 1.38 2.83
sqlserver neither 8 10 662 6616 10.62 72.07 9.53 70.92
sqlserver neither 32 10 667 6675 45.48 75.83 44.24 74.62
sqlserver neither 128 10 613 6129 110.08 356.87 108.36 339.31
sqlserver efcore 1 1 245 245 4.00 9.59 1.25 1.60
sqlserver efcore 8 1 660 660 11.93 15.33 7.86 10.62
sqlserver efcore 32 1 600 600 51.76 81.43 47.26 76.36
sqlserver efcore 128 1 582 582 122.80 352.79 118.18 345.71
sqlserver efcore 1 10 235 2347 4.17 6.79 1.41 2.05
sqlserver efcore 8 10 574 5744 13.56 22.27 9.45 17.74
sqlserver efcore 32 10 525 5253 58.41 116.19 53.94 113.61
sqlserver efcore 128 10 502 5016 127.80 2067.20 121.69 231.34

Reading the numbers

  • Appends serialize on the position counter from its update to commit, so throughput peaks at a few writers and falls slowly as more writers queue.
  • More events per append cost little: 10 events per append move about 10 times the events at a similar append rate.
  • With many writers, latency is almost all counter wait: counter p50 is close to append p50.
  • One table is one run of one runner. Read the cells as an order of magnitude, not as a figure to quote.

The spread between runs

A GitHub-hosted runner gives a different answer every night, for the same code. Seven nightly runs measure identical benchmarked code: src and bench do not change from commit 0a704c0 to commit 168d306. These are their rates for the peak Postgres cell, 8 writers and 1 event per append, and for the SQL Server single-writer cell:

Run Commit Postgres 8×1 appends/s SQL Server 1×1 appends/s
2026-10-17 0a704c0 846 395
2026-10-18 0a704c0 1345 670
2026-10-19 0a704c0 1142 471
2026-10-20 0a704c0 1097 250
2026-10-21 7a006bd 853 418
2026-10-21 168d306 1038 412
2026-10-21 168d306 841 376

The spread belongs to the run, not to one code path: a run is fast or slow in every cell of a provider at once. Against the median of these seven runs, a Postgres run sits between 0.82 and 1.29, and a SQL Server run between 0.71 and 1.52. The worst single cell falls 21.8% below its median on Postgres, and 51.6% on SQL Server. Each run publishes its own table and JSON as the benchmarks artifact of the nightly workflow. Read that artifact for the numbers of one run.

These numbers compare releases on the same runner type. They are not a production sizing guide.

The nightly gate

bench/baseline.json holds the median appends/s of each cell over those seven runs, with the ID and the commit of every run it was sampled from. The nightly job prints a REGRESSION line and fails when a cell’s appends/s falls more than the band of its provider below that median: 40% on Postgres, 65% on SQL Server. Each band is wider than the worst drop measured on unchanged code, so a red benchmark job reports a regression and not runner variance. just bench applies the same bands on your own machine, against numbers that a runner measured.