MongoDB 9.0 Performance: A Quick Comparison With 8.0 and 8.3
- Ivan Groenewold
- 956 reads
In a controlled three-replica-set test, MongoDB 9.0 used less CPU per operation and led most clearly when CPU was the bottleneck.

MongoDB 9.0’s performance edge in this quick test depended on what constrained the server. It used less CPU per operation than the two 8.x versions across all three data sizes, and delivered about 6% more throughput when CPU was the limiting resource. When data fit comfortably in memory, or storage became the limit, the gain narrowed to about 2%. That’s a useful signal for teams planning their own upgrade tests, not a case for changing production systems on these results alone.

The comparison covered MongoDB Community 9.0.4, Percona Server for MongoDB 8.0.34-15, and Percona Server for MongoDB 8.3.13-4. Percona Server for MongoDB (PSMDB) uses the same upstream code; its additional features were disabled for this test. Each version ran on an identical three-node replica set in Google Cloud, deployed with PSMDB Sandbox. The test author describes the work as an initial check: one workload, one hardware configuration, and three data sizes.

The workload and its limits
The benchmark used PLGM’s built-in flights workload against the airline.flights collection, which had seven secondary indexes. Its mix was 60% finds using flight_id lookups, 20% updates, 10% deletes and 10% inserts. Updates and deletes combined single-document operations by flight_id with multi-document operations by _id. Inserts came in batches of ten. Writes used the server’s default write concern, so their work included replication.
Sixteen workers sent commands continuously, without a pause between operations. The collection was dropped and reseeded before each iteration. Queries read seeded documents while inserts increased the collection during a run. The three data sizes were 1 million, 4 million and 8 million documents.
“Fits in RAM” in this test refers to compressed data fitting in the operating system’s file cache. In that situation, a WiredTiger cache miss generally did not require a disk read. At 8 million documents, the compressed collection approached the server’s total memory; the stated compression ratio was about 2:1, leaving roughly a quarter of the documents able to fit in the WiredTiger cache.
Traffic was deterministic: a fixed seed and each command’s iteration, worker and operation number produced the same sequence for every version. In the 1 million and 4 million runs, all versions completed at least one 250,000-command pass per worker, and PLGM reported matching traffic fingerprints. At 8 million, no server completed a pass within 30 minutes. Each processed the first 2.7–2.8 million commands in the same sequence, so the results were incomplete but still allowed an operation-by-operation comparison. PLGM ran the versions one after another, giving each run the load generator to itself.
Where 9.0 pulled ahead

Throughput for the 1 million, 4 million and 8 million document runs; percentages are relative to MongoDB 9.0.4.

Average latency across the three data sizes.
The aggregate result is clearest when read alongside the changing workload conditions. With smaller data sets, and thus less pressure from storage, 9.0 led overall. Its advantage was especially apparent in the 4 million document run: it remained ahead throughout the run, and its average, median, 95th-percentile and 99th-percentile latency were all lower. At 8 million documents, the latency tails were similar across versions and throughput lines overlapped much of the time.

Throughput over time for 1 million documents, averaged by minute. Each line uses its own run clock.

Throughput over time for 4 million documents, averaged by minute; 9.0 led throughout.

Throughput over time for 8 million documents, averaged by minute; the results overlap for much of the run.
The operation-level pattern shifted with data size. At 1 million documents, 9.0’s lead over 8.0 was concentrated mostly in writes. At 4 million, finds showed the largest difference, with a 12% advantage. At 8 million, single-document updates and deletes by flight_id were roughly even, or slightly faster on 8.0. Those operations must fetch documents that are likely outside memory. MongoDB 9.0 retained an advantage on finds, inserts and operations by _id.

Average, median, 95th-percentile and 99th-percentile latency for 4 million and 8 million documents.

Average latency for 8.0 and 8.3 relative to 9.0, broken down by operation and data size.
Same plans, different cost
PLGM captured explain output for samples after each run. All three versions selected the same plans at every data size: finds used LIMIT → FETCH → IXSCAN on flight_id_1_equipment.plane_type_1; updates and deletes by flight_id used UPDATE or DELETE → FETCH → IXSCAN on that index; and multi-document operations by _id used EXPRESS_UPDATE or EXPRESS_DELETE on _id_. Different index choices therefore don’t explain the measured gaps. The results point instead to differences in the work required to execute equivalent plans, though this test does not identify the cause.
The practical takeaway is modest but useful: 9.0 looks more efficient when CPU limits throughput, while the benefit can shrink when memory or storage shapes performance. Percona Server for MongoDB 8.3 was slowest whenever CPU mattered. Teams evaluating an upgrade should first identify their own bottleneck and run representative queries against their own data; this workload cannot predict every application’s results.
Reproducing the comparison
The environment used three replica sets, a PLGM host and PMM on Google Cloud. Database nodes were n2-standard-4 instances with 80 GB SSD data volumes, Intel Ice Lake CPUs and GVNIC networking. PLGM ran on an n2-highcpu-8 host. The test configuration used the same MongoDB versions listed above and disabled Percona Backup for MongoDB and mongot for the Community 9.0 instance.
PLGM was available through the sandbox host’s web interface. The 1 million document run used 16 workers, a 30-minute duration, three iterations, five minutes between iterations, deterministic traffic with seed 178477, and a batch size of ten for inserts. It set the operation mix to 60% finds, 20% updates, 10% deletes and 10% inserts, with aggregation and transactions disabled. The 4 million and 8 million runs used one iteration each. The reported traffic fingerprints were c0a88fae… for 1 million documents and 9734a782… for 4 million.
For most teams, adapting the workload matters more than reproducing these exact settings. PLGM supports custom collection definitions and queries, as well as replaying captured traffic. Repeating the comparison at different concurrency levels and with faster storage would help separate CPU effects from storage pressure; the test author also plans to investigate why 8.3 required more CPU. Until then, 9.0 merits evaluation on workload-specific evidence rather than an urgent upgrade.