Performance Benchmarking

Measuring the Impact of Indexing on Write Performance

In this lesson, you will learn how to quantify the performance trade-off that occurs when adding indexes to a document-based database.

While we often think of indexes as a "magic button" to speed up read operations, they come with a hidden cost: the write penalty. Every time you insert, update, or delete a document, the database engine must also perform a synchronized update to every index associated with that collection.

The Mechanism of the Penalty

Think of an index as a secondary data structure (often a B-Tree). When you add a document to a collection, the database doesn't just save that document to disk; it also calculates the keys for every index and inserts them into those secondary structures. If you have ten indexes on a collection, a single write operation might trigger eleven distinct disk I/O operations.

Practical Benchmarking Strategy

To measure this impact, you should perform an A/B test in your staging environment. Do not rely on theoretical guesses; simulate your production write load under two scenarios:

1. Baseline: Measure the time required to perform 10,000 document inserts on a collection with minimal indexing.
2. Post-Index: Apply your proposed indexing strategy and repeat the exact same workload.

You can use a simple script to track the latency:

// A simple benchmarking snippet
const startTime = Date.now();

for (let i = 0; i < 10000; i++) {
  db.orders.insertOne({ orderId: i, status: "pending", timestamp: new Date() });
}

const endTime = Date.now();
console.log(`Execution time: ${endTime - startTime}ms`);

If your execution time spikes from 200ms to 2,000ms after adding three new indexes, you have identified a significant write-path bottleneck. This data is critical for your Schema Design Reviews, as it forces a conversation about whether the read-speed gains of a new index are worth the degradation in write throughput. In high-concurrency systems, excessive indexing can lead to lock contention, making it even harder to maintain the performance levels you achieved during Load Testing Document Systems.

Key Takeaway: Every index you add improves read latency but imposes a cumulative tax on write operations; always benchmark the write-path degradation before finalizing your indexing strategy.