How MongoDB B-Tree Indexes Work
Learners will trace how MongoDB stores index entries in a B-tree and how the query planner walks the tree to satisfy a filter.
How MongoDB B-Tree Indexes Work is a free MongoDB Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the MongoDB Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Why Indexes Exist
Without an index, MongoDB must scan every document in a collection to satisfy a query—this is called a collection scan (COLLSCAN). On a collection with millions of documents, a COLLSCAN can take seconds or even minutes. An index is a separate, ordered data structure that lets MongoDB jump directly to the matching documents in microseconds.
The B-Tree Data Structure
MongoDB uses a B-tree (balanced tree) to store index entries. A B-tree is organised as a hierarchy of nodes: a root node at the top, internal nodes in the middle, and leaf nodes at the bottom. Every node holds multiple key-value pairs and pointers to child nodes. The tree stays balanced—all leaf nodes are at the same depth—so lookups always take the same number of steps regardless of which value you search for.
How Index Entries Are Stored
When you create an index on a field like age, MongoDB builds a B-tree where each leaf node entry contains the indexed field value paired with a pointer (the RecordId) to the actual document on disk. The entries are sorted in ascending or descending order based on how you define the index. Because the tree is sorted, MongoDB can satisfy equality lookups, range queries, and sort operations all from the same structure.
// Index on 'age' field
db.users.createIndex({ age: 1 });
// MongoDB now has a sorted B-tree:
// 18 -> RecordId(doc1)
// 25 -> RecordId(doc4)
// 31 -> RecordId(doc2)
// 47 -> RecordId(doc7)The Query Planner and IXSCAN
Every query passes through MongoDB's query planner, which evaluates available indexes and chooses the most efficient execution plan. When the planner finds a suitable index, it uses an IXSCAN (index scan) stage instead of a COLLSCAN. An IXSCAN traverses the B-tree from root to the matching leaf nodes, then fetches only the relevant documents from disk using their RecordId pointers.
// See which plan MongoDB chose
db.users.find({ age: { $gt: 30 } }).explain('executionStats');Equality, Range, and Sort Index Use
A B-tree index supports three types of access patterns: equality lookups (find the exact key), range scans (traverse contiguous leaf nodes between two bounds), and sort operations (the tree is already ordered, so no in-memory sort is needed). This triple capability makes a well-placed index dramatically more useful than it might first appear.
// Equality - single leaf node lookup
db.users.find({ username: 'alice' });
// Range - scan contiguous leaf nodes
db.users.find({ age: { $gte: 20, $lte: 30 } });
// Sort - traverses tree in order, no sort stage
db.users.find({}).sort({ age: 1 });Index Direction: Ascending vs Descending
When you create an index with 1 the entries are stored in ascending order; -1 stores them in descending order. For a single-field index, direction doesn't matter much because MongoDB can traverse the B-tree in either direction. Direction becomes critical in compound indexes where the combination of directions must match the sort order your queries use.
// Ascending index
db.orders.createIndex({ createdAt: 1 });
// Descending index (useful for 'newest first' sorts)
db.orders.createIndex({ createdAt: -1 });Index Size and Memory
MongoDB tries to keep the working set of indexes in RAM (the WiredTiger cache). When an index fits entirely in memory, lookups are essentially free I/O operations. When an index is too large for RAM, MongoDB must page index nodes in from disk, which causes latency spikes. This is why you should keep indexes lean—only index the fields you actually query, and use projection to avoid returning unused data.
// Check index sizes in bytes
db.users.stats().indexSizes;
// Example output:
// { '_id_': 856064, 'age_1': 442368 }Covered Queries
A covered query is one where all the fields in the filter and projection are present in the index. MongoDB can answer such a query using only the index B-tree—it never has to fetch the actual document from disk. Covered queries are extremely fast and are worth designing for on your hottest read paths.
// Index on email and name
db.users.createIndex({ email: 1, name: 1 });
// Covered query: filter on email, project email+name only
// MongoDB only reads the index, never the document
db.users.find(
{ email: 'a@b.com' },
{ _id: 0, email: 1, name: 1 }
);The _id Index Is Always Present
Every MongoDB collection automatically has a unique B-tree index on _id. This default index is why lookups by _id are always fast, even on enormous collections. You cannot drop the _id index. All other indexes are optional and must be created explicitly by the developer or DBA.
// MongoDB creates this automatically:
// { '_id': 1 } (unique)
// Fast because _id is always indexed:
db.orders.findOne({ _id: ObjectId('64a1f...') });Write Overhead of Indexes
Indexes speed up reads but slow down writes. Every insert, update, or delete must update not only the document on disk but also every B-tree that indexes a field on that document. A collection with 10 indexes incurs 10 extra B-tree writes per insert. This trade-off means you should only create indexes that serve real query patterns—zombie indexes that nobody uses still pay the write tax.
// List all indexes and their sizes
db.users.getIndexes();
// Identify unused indexes (MongoDB 4.4+)
// $indexStats shows usage counts since last restart
db.users.aggregate([{ $indexStats: {} }]);Multikey Indexes for Arrays
When you index a field that contains an array, MongoDB creates a multikey index—it inserts one B-tree entry per array element. This allows queries like { tags: 'mongodb' } to use the index even though tags is an array. MongoDB detects array fields automatically and sets the multikey flag; you don't need to do anything special when creating the index.
// Document with array field
// { title: 'Guide', tags: ['mongodb', 'nosql', 'database'] }
// Single index creation
db.articles.createIndex({ tags: 1 });
// MongoDB creates THREE B-tree entries:
// 'database' -> RecordId
// 'mongodb' -> RecordId
// 'nosql' -> RecordId
// This query now uses IXSCAN
db.articles.find({ tags: 'mongodb' });Quick Check
Test your understanding of MongoDB B-Tree indexes from this lesson.
Lesson Recap
In this lesson you learned: MongoDB uses B-tree structures where sorted leaf entries point to document RecordIds, the query planner chooses IXSCAN over COLLSCAN when a suitable index exists, and indexes accelerate reads but add write overhead. Next up we explore creating single-field and compound indexes.
Frequently asked questions
Is the “How MongoDB B-Tree Indexes Work” lesson free?
Yes — the full text of “How MongoDB B-Tree Indexes Work” is free to read here on the web, and the MongoDB Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the MongoDB Academy course, upgrade to CoddyKit PRO.
What will I learn in “How MongoDB B-Tree Indexes Work”?
Learners will trace how MongoDB stores index entries in a B-tree and how the query planner walks the tree to satisfy a filter. You practise MongoDB Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start MongoDB Academy?
No prior experience is required. MongoDB Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “How MongoDB B-Tree Indexes Work” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this MongoDB Academy lesson?
Yes. Every MongoDB Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.