Unbound: MongoDB at Scale

Performance Engineering from the Java Driver to the WiredTiger Storage Engine.

This book targets senior backend developers who have scaled a MongoDB cluster by paying for larger instances, sharded a database on the wrong key and ruined latency, or brought down production with a Spring Data @Query that triggered an unbounded $lookup. The reader has a production cluster on fire. This book gives them the tools to diagnose it, measure it, and fix it without guessing.

Every chapter uses the same domain: a high-traffic IoT telemetry and social analytics platform. Raw sensor data ingestion at thousands of writes per second, user activity feeds with mixed read-write workloads, real-time aggregation pipelines, and heavy analytical queries running alongside operational traffic. The domain stresses every layer: JVM garbage collection from BSON parsing, network payload size from bloated documents, WiredTiger cache limits from working set overflow, replica set lag from write-heavy secondaries, and shard router scatter-gather overhead from poorly scoped queries. Every chapter uses this platform for benchmarks, profiling examples, and optimization scenarios.

Four positions run through every chapter:

Measure before you change anything. Adding an index without checking the explain("executionStats") output is a guess. Every chapter that introduces an optimization requires a JMH benchmark, a k6 load test result, a query execution plan, or an APM trace before and after the change. Opinion without a number is not performance engineering.

Schema design is your highest leverage point. Changing driver configurations is a micro-optimization. Replacing an unbounded array with an outlier pattern or converting individual events into a bucket pattern on a collection taking 10,000 writes per second is architectural. This book treats document data modeling as a strict performance discipline applied to real data shapes.

The bottleneck is almost never the database engine. Senior engineers consistently blame MongoDB when the actual bottleneck is connection pool exhaustion, BSON serialization overhead in the JVM, or the Spring Data MongoDB mapping tax. This book treats the application layer and the driver as the primary suspects in any latency investigation.

WiredTiger is not magic. The storage engine has mechanical limits. Cache eviction pressure, checkpointing stalls, and concurrent write ticket exhaustion are predictable consequences of workload patterns. Treating the storage engine as a black box leads to catastrophic degradation under load.

Code examples use Java 21, Spring Boot 3, and the MongoDB Java Sync Driver. JMH benchmarks measure JVM-level performance. k6 scripts measure end-to-end throughput. Every explain("executionStats") output is shown before and after an optimization. Every chapter follows the same structure: the symptom, the cause, a benchmark that quantifies the problem, the fix, the proof with the delta shown, and the trade-off stated plainly.

This book was generated using AI assistance.