Measured, not promised
Every number on this page is measured on the same machine, through the same pymongo client, against the same on-disk WiredTiger storage — with real mongod as the reference — both measured against mongod 8.0.32 on a dedicated cloud instance, as part of cutting the release they describe. Two dimensions: per-operation latency (one client, nine workloads) and throughput under concurrent writers (1–8 parallel writer processes). Both harnesses ship in the repo; both tables regenerate with one command.
Per-operation latency
“Rust DB” here is the Rust MongoDB server — these harnesses drive the MongoDB wire protocol, so the Rust PostgreSQL server is measured separately, against PostgreSQL. Bar length is how many times slower than mongod each server is — median of five runs per workload, 10,000-document dataset, end-to-end through the wire protocol and driver.
Data table (with raw milliseconds)
| Workload | mongod | Rust DB | x mongod |
|---|---|---|---|
| insert (10k docs) | 177.4 ms | 259.2 ms | 1.5x |
| find indexed range | 17.1 ms | 22.2 ms | 1.3x |
| find full scan | 33.5 ms | 40.8 ms | 1.2x |
| find filtered scan | 25.8 ms | 35.7 ms | 1.4x |
| update_many (half) | 231.9 ms | 273.1 ms | 1.2x |
| aggregate $group | 18.9 ms | 53.0 ms | 2.8x |
| aggregate multi-stage | 26.7 ms | 69.2 ms | 2.6x |
| delete_many (half) | 96.2 ms | 343.1 ms | 3.6x |
| change-stream drain* | 178.5 ms | 241.0 ms | 1.4x |
The short version: the Rust DB runs at 1.2x–3.6x of mongod per operation (medians of 15 interleaved repetitions, 2026-11-18). Reads, update_many and the change-stream drain are at 1.2–1.4x, and delete_many and aggregation are at the high end. Both servers run as a single-node replica set, so a default write waits for the journal on both. Earlier tables compared against a standalone mongod, which does not wait for the journal, so they are not comparable with this one. Both servers sit on the identical WiredTiger C library; the gaps are the layers above it. Methodology & how to reproduce →
Throughput under concurrent writers
Does throughput grow with writers? Each line is a server's aggregate throughput relative to its own single-writer rate — N writer processes each streaming insert_many batches for 30 seconds against their own collections.
Data table (absolute docs/second)
| Writers | mongod | Rust DB | Rust DB — async stack |
|---|---|---|---|
| 1 | 5,900 | 4,000 | 7,400 |
| 2 | 9,800 | 6,100 | 12,000 |
| 4 | 15,400 | 8,300 | 15,500 |
| 8 | 19,700 | 10,200 | 17,200 |
Two servers, honestly told, both as a single-node replica set with journaled default writes (2026-11-18). mongod scales furthest: 3.4x its own single-writer rate at eight writers. That is its C++ scheduler above WiredTiger doing its job. The Rust DB scales monotonically: 1.5x at two writers, 2.1x at four and 2.6x at eight (10.2k docs/s), with no cliff. The per-collection write-lock split, RecordId keying, a key-only oplog prune and append-tuned oplog btrees removed the old peak-then-collapse shape. The flattening that remains is WiredTiger itself: cache eviction and checkpoint pressure in one embedded connection, not a SecantusDB lock. The Rust DB's async stack starts highest (dashed): opting into the async + non-logged oplog (oplog_async + oplog_nonlogged) moves the oplog write off the writers' critical path. It runs at 7.4k docs/s with one writer, against mongod's 5.9k, and stays level with mongod up to four writers. The trade is crash durability of the oplog tail; data stays fully durable, and change streams stay exactly-once. Passes on a shared droplet are noisy, so read the shapes. The full concurrency story →
What to make of it
The trade SecantusDB started from was conformance and WiredTiger durability over raw speed. The Rust server closed most of that gap: at 1.2x–3.6x of mongod per operation, both durable, and scaling monotonically with writers, per-op latency has stopped being the reason to reach for a real mongod instead. What remains a reason is everything single-node scope excludes — replica sets, sharding, a cluster to fail over. And because the wire protocol is identical, moving between them is a connection-string change.
Caveats that apply to every number here: one machine (a dedicated 8-vCPU cloud instance, not a laptop — a laptop moves every column at once and nothing in the output says so), no network, no concurrent readers mixed with writers, dataset that fits in cache. The harnesses (bench.compare_servers, bench.concurrency) ship in the repository — run them on your own hardware and workload before drawing conclusions that matter.