Benchmarks

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.

Rust DB mongod = 1x reference
2x3x4xmongod = 1xinsert (10k docs)1.5xfind indexed range1.3xfind full scan1.2xfind filtered scan1.4xupdate_many (half)1.2xaggregate $group2.8xaggregate multi-stage2.6xdelete_many (half)3.6xchange-stream drain1.4x
Data table (with raw milliseconds)
WorkloadmongodRust DBx mongod
insert (10k docs)177.4 ms259.2 ms1.5x
find indexed range17.1 ms22.2 ms1.3x
find full scan33.5 ms40.8 ms1.2x
find filtered scan25.8 ms35.7 ms1.4x
update_many (half)231.9 ms273.1 ms1.2x
aggregate $group18.9 ms53.0 ms2.8x
aggregate multi-stage26.7 ms69.2 ms2.6x
delete_many (half)96.2 ms343.1 ms3.6x
change-stream drain*178.5 ms241.0 ms1.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.

mongodRust DBRust DB — async stack
1x2x3x1248concurrent writersmongod 3.4xRust 2.6xasync 2.3x
Data table (absolute docs/second)
WritersmongodRust DBRust DB — async stack
15,9004,0007,400
29,8006,10012,000
415,4008,30015,500
819,70010,20017,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.