MongoDB Indexing Strategies for Performance Optimization

Database MongoDB
Team CNC
26 February 2025
0
11 minutes read

Indexes in MongoDB play a crucial role in improving query performance by enabling faster data retrieval. Without indexes, MongoDB performs a collection scan, which can be slow for large datasets. Proper indexing strategies help optimize query performance and reduce database load.

This guide explains MongoDB indexing types, best practices, and strategies for performance optimization.

1. Understanding Indexes in MongoDB

An index is a data structure that stores a subset of a collection’s fields in an efficiently searchable format.

Benefits of Indexing:

Speeds up queries by reducing search time.
Reduces CPU and memory usage.
Helps with sorting and filtering data efficiently.

2. Types of Indexes in MongoDB

2.1 Single-Field Index

Indexes a single field, improving search performance for that field.

db.users.createIndex({ email: 1 })  // 1 for ascending order

Use this when frequently querying a single field (e.g., email).

2.2 Compound Index

Indexes multiple fields together, optimizing queries that filter by multiple fields.

db.orders.createIndex({ customerId: 1, orderDate: -1 })  // Ascending & Descending

Use compound indexes when queries filter by multiple fields frequently.

2.3 Multikey Index

Indexes arrays, allowing searches on array elements.

db.products.createIndex({ tags: 1 })

Useful for fields that store lists or tags.

2.4 Text Index

Supports full-text search for string fields.

db.articles.createIndex({ content: "text" })

Use text indexes for searching words inside text fields.

2.5 Geospatial Index

Optimizes location-based queries like finding nearby places.

db.locations.createIndex({ coordinates: "2dsphere" })

Essential for geo-based applications.

2.6 Hashed Index

Distributes indexed values randomly, optimizing sharded collections.

db.users.createIndex({ userId: "hashed" })

Use hashed indexes for even distribution in a sharded environment.

3. Best Practices for Indexing in MongoDB

3.1 Use Indexes on Frequently Queried Fields

Create indexes on fields used in filter (find()), sort (sort()), and join ($lookup) operations.
Example: Queries often filter by status, so indexing improves performance.
```
db.orders.createIndex({ status: 1 })
```

3.2 Avoid Too Many Indexes

Indexes consume RAM and slow down inserts/updates.
Use only the necessary indexes to balance performance.

3.3 Optimize Index Order in Compound Indexes

Order matters in compound indexes.
Example: Queries filtering by customerId and sorting by orderDate work best with:
```
db.orders.createIndex({ customerId: 1, orderDate: -1 })
```

3.4 Use Covered Queries

A covered query retrieves all required fields from the index without accessing the collection.

✔ Example:

db.orders.find({ customerId: 101 }, { customerId: 1, orderDate: 1, _id: 0 })

If an index exists on { customerId: 1, orderDate: 1 }, MongoDB can serve this query from the index alone.

3.5 Remove Unused Indexes

Unused indexes consume storage and slow down writes.
Find unused indexes with:

db.collection.getIndexes()

Remove an unused index:

db.orders.dropIndex("status_1")

3.6 Monitor Index Usage with explain()

Use .explain("executionStats") to analyze query performance.

db.orders.find({ status: "shipped" }).explain("executionStats")

Look for IXSCAN (Index Scan) instead of COLLSCAN (Collection Scan).

4. Indexing Strategies for Performance Optimization

4.1 Create Indexes Based on Query Patterns

Analyze frequent queries and index the relevant fields.

Example:
Query → db.orders.find({ customerId: 101, status: "shipped" })
Solution → Compound index:

db.orders.createIndex({ customerId: 1, status: 1 })

4.2 Use Sparse Indexes for Fields with Missing Values

Sparse indexes store only documents containing the indexed field, reducing index size.

db.users.createIndex({ phoneNumber: 1 }, { sparse: true })

Saves space when some documents don’t have phoneNumber.

4.3 Use Partial Indexes for Filtering Specific Data

Partial indexes store only documents meeting specific conditions.

db.orders.createIndex({ status: 1 }, { partialFilterExpression: { status: { $exists: true } } })

Reduces index size and improves performance.

4.4 Use TTL Indexes for Expiring Data

Time-To-Live (TTL) indexes automatically delete old documents, useful for logs or sessions.

db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })

Deletes records 1 hour after creation.

4.5 Optimize Sorting with Indexes

MongoDB can use indexes to sort efficiently.

Example query:

db.orders.find().sort({ orderDate: -1 }).limit(10)

Solution → Ensure index exists:

db.orders.createIndex({ orderDate: -1 })

5. Checking Index Performance in MongoDB

5.1 List All Indexes in a Collection

db.users.getIndexes()

5.2 View Index Size

db.collection.stats().indexSizes

5.3 Check Query Performance Using Profiler

Enable the profiler to log slow queries:

db.setProfilingLevel(2)
db.system.profile.find().pretty()

6. Conclusion

Indexing is a powerful optimization tool in MongoDB. Properly designed indexes improve query performance while minimizing storage and computation overhead.

Key Takeaways:

Use single-field indexes for frequent queries.
Use compound indexes for multi-field filtering.
Avoid too many indexes (they slow down inserts/updates).
Use TTL, sparse, and partial indexes for special cases.
Analyze performance with explain() and profiling tools.