How do indexes work in MongoDB?

Question

Accepted Answer

**Indexes** in MongoDB speed up queries by letting the database find documents without scanning the whole collection — just like in relational databases. Without indexes, queries do a **collection scan** (checking every document); with them, lookups are fast. MongoDB supports several index types.

## Creating and using indexes

```js
// without an index, this scans EVERY document (slow on a big collection)
db.users.find({ email: "ann@x.com" });

// create an index → fast lookups
db.users.createIndex({ email: 1 });        // 1 = ascending (B-tree index)
db.users.find({ email: "ann@x.com" });     // now uses the index

db.users.getIndexes();                      // list indexes
```

The default `_id` field is always indexed. You add indexes on fields you query, sort, or filter by frequently.

## Compound indexes (multiple fields)

```js
// a compound index on multiple fields — order matters!
db.users.createIndex({ country: 1, age: -1 });
// helps: { country: ? }, { country: ?, age: ? }  (leftmost prefix)
// does NOT help: { age: ? } alone
```

**Compound indexes** cover queries on multiple fields, but the **field order matters** (the index supports queries using a leftmost prefix of its fields — a key rule to understand).

## Index types

```text
Single field    → { field: 1 }
Compound        → { a: 1, b: -1 } (multiple fields)
Multi-key       → automatically created when indexing an ARRAY field (indexes each element)
Text            → text search on string content
Geospatial      → 2dsphere for location queries
Hashed          → for hashed sharding
TTL             → { createdAt: 1 } with expireAfterSeconds → auto-delete old docs
Unique          → { email: 1 }, { unique: true } → enforce uniqueness
Partial/Sparse  → index only some documents
```

## The trade-off (same as SQL)

```text
✓ Indexes speed up reads dramatically (collection scan → index lookup)
✗ But they consume storage and SLOW DOWN writes (each write updates indexes)
→ Index what you query frequently; don't over-index (hurts writes). Use explain()
  to verify queries use indexes (look for COLLSCAN = bad, IXSCAN = good).
```

## Why it matters

Indexes are one of the most important topics for MongoDB performance — they're the primary tool for making queries fast, and the principles are similar to relational databases, so understanding them is essential knowledge for performant MongoDB applications.

Without indexes, queries require **collection scans** (checking every document — catastrophically slow as collections grow), while indexes enable fast lookups — often the difference between a query taking milliseconds versus seconds.

Understanding how to create indexes on frequently-queried/sorted/filtered fields is fundamental. **Compound indexes** (covering multiple-field queries) are important, especially the rule that **field order matters** (an index supports queries using a leftmost prefix of its fields — a key concept for designing effective compound indexes).

Knowing the MongoDB-relevant index types is valuable: **multi-key indexes** (automatically indexing array elements — important given MongoDB's array-heavy documents), **TTL indexes** (auto-expiring old documents — useful for sessions, logs, temporary data), **unique indexes** (enforcing uniqueness), text and geospatial indexes for specialized queries, and partial/sparse indexes.

Understanding the **trade-off** (indexes speed reads but consume storage and slow writes, so index what you query without over-indexing) and using **`explain()`** to verify queries use indexes (COLLSCAN = bad scan, IXSCAN = good index use) is the key practical skill for optimization.

Since query performance is critical and proper indexing is the most impactful MongoDB optimization, understanding indexes — how they work, compound index ordering, the MongoDB-specific types (multi-key, TTL, unique), the read/write trade-off, and verifying with explain() — is essential, high-value knowledge for performant MongoDB applications and one of the most important MongoDB topics, paralleling indexing's importance in SQL databases.