How to Create MongoDB Index

Database performance is one of the most critical factors in modern application development. As data volumes grow, query response times can degrade dramatically without proper optimization. MongoDB, as a leading NoSQL database, provides powerful indexing capabilities to accelerate data retrieval, reduce latency, and improve overall system efficiency. Creating MongoDB indexes correctly is not just a technical taskits a strategic decision that impacts scalability, user experience, and operational costs.

This comprehensive guide walks you through everything you need to know about creating MongoDB indexesfrom basic syntax to advanced optimization techniques. Whether youre a developer, database administrator, or systems architect, understanding how to build, manage, and refine indexes will empower you to design high-performance MongoDB applications that scale gracefully under load.

Step-by-Step Guide

Understanding What an Index Is in MongoDB

An index in MongoDB is a special data structure that stores a small portion of the collections data in an easy-to-traverse form. Instead of scanning every document in a collection to find matching results, MongoDB can use an index to quickly locate the relevant documents. Think of it like the index in a book: instead of reading every page to find a topic, you flip to the page number listed in the index.

Without indexes, MongoDB performs a collection scaniterating through every document in a collection. This becomes prohibitively slow as collections grow beyond a few thousand documents. Indexes reduce query time from O(n) to O(log n) or even O(1) in ideal cases.

Prerequisites

Before creating indexes, ensure you have:

• MongoDB installed (version 4.0 or later recommended)
• Access to the MongoDB shell (mongosh) or a GUI tool like MongoDB Compass
• A sample collection with data to test indexing

You can install MongoDB via official packages, Docker, or cloud platforms like MongoDB Atlas. For this guide, we assume youre using the MongoDB shell connected to a local or remote instance.

Step 1: Connect to Your MongoDB Instance

Open your terminal or command prompt and connect to your MongoDB server:

mongosh

If your MongoDB instance requires authentication or runs on a non-default port, use:

mongosh "mongodb://username:password@localhost:27017/database_name"

Once connected, switch to the database containing your target collection:

use myapp

Step 2: Examine Your Collection and Query Patterns

Before creating an index, analyze your most frequent queries. Use the explain() method to inspect how queries are executed:

db.users.find({ email: "john@example.com" }).explain("executionStats")

Look for the stage field in the output. If it says COLLSCAN, your query is performing a full collection scanthis is a strong indicator that an index is needed.

Common query patterns to index include:

• Equality matches (e.g., { status: "active" })
• Range queries (e.g., { age: { $gt: 18 } })
• Sorting operations (e.g., sort({ createdAt: -1 }))
• Text searches (e.g., { $text: { $search: "mongodb" } })

Step 3: Create a Single Field Index

The simplest index type is a single field index. To create one, use the createIndex() method:

db.users.createIndex({ email: 1 })

The number 1 indicates ascending order; -1 indicates descending order. For email lookups, ascending is standard since youre typically searching for exact matches.

MongoDB automatically creates a unique index on the _id field during collection creation. You cannot drop this index, but you can create additional indexes on other fields.

Step 4: Create a Compound Index

Compound indexes combine multiple fields into a single index structure. Theyre essential for queries that filter on more than one field.

Example: You frequently query users by country and status:

db.users.find({ country: "USA", status: "active" })

Create a compound index:

db.users.createIndex({ country: 1, status: 1 })

Order matters in compound indexes. MongoDB can use this index for queries that match the prefix of the index. For example:

• { country: "USA" } ? ? Uses index
• { country: "USA", status: "active" } ? ? Uses index
• { status: "active" } ? ? Does NOT use index

If you also need to query by status alone, consider creating a separate index on status, or reorder the compound index based on query frequency and selectivity.

Step 5: Create a Unique Index

Unique indexes ensure that no two documents have the same value for the indexed field(s). This is commonly used for email addresses, usernames, or product SKUs.

db.users.createIndex({ email: 1 }, { unique: true })

If you attempt to insert a document with a duplicate email, MongoDB will throw a duplicate key error:

E11000 duplicate key error collection: myapp.users index: email_1 dup key: { email: "john@example.com" }

Unique indexes are especially important in applications requiring data integrity, such as authentication systems or e-commerce platforms.

Step 6: Create a Text Index

Text indexes support full-text search capabilities. They are ideal for searching within string content, such as product descriptions, blog posts, or user comments.

To create a text index on a field:

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

You can also create a text index across multiple fields:

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

Once created, use the $text operator to search:

db.articles.find({ $text: { $search: "MongoDB tutorial" } })

Text indexes are case-insensitive and ignore stop words (e.g., the, and). They also support stemming (e.g., running matches run).

Step 7: Create a Geospatial Index

Geospatial indexes are used for location-based queries, such as finding nearby restaurants or tracking delivery drivers.

For 2D coordinates (latitude/longitude), use a 2dsphere index:

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

Then query using $near or $geoWithin:

db.locations.find({
location: {
$near: {
$geometry: {
type: "Point",
coordinates: [-73.99279, 40.719296]
},
$maxDistance: 1000
}
}
})

Geospatial indexes require data in GeoJSON format or legacy coordinate pairs.

Step 8: Create a Hashed Index

Hashed indexes are used for sharding and can improve performance on high-cardinality fields where range queries are not needed.

Hashed indexes store the hash of the fields value. They are ideal for equality matches but not for range queries or sorting.

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

Use this index for queries like:

db.users.find({ userId: "abc123" })

Do NOT use hashed indexes for queries involving $gt, $lt, or sorting, as they will not be utilized.

Step 9: Create a Partial Index

Partial indexes index only documents that meet a specified filter condition. They reduce index size, improve write performance, and save storage.

Example: Index only active users:

db.users.createIndex({ email: 1 }, { partialFilterExpression: { status: "active" } })

Now, queries filtering on status: "active" and email will use this index. Queries on inactive users will not.

Partial indexes are excellent for sparse data or when you only need to optimize a subset of your documents.

Step 10: Create a Sparse Index

Sparse indexes only include documents that have the indexed field. Documents without the field are excluded from the index.

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

This is useful when not all documents have the fielde.g., not every user has a phone number. A sparse index avoids bloating the index with null values and improves efficiency.

Note: Sparse indexes do not support unique constraints unless combined with partialFilterExpression.

Step 11: View Existing Indexes

To see all indexes on a collection:

db.users.getIndexes()

This returns an array of index objects, each with details like name, key pattern, unique flag, and options.

Step 12: Drop an Index

If an index is no longer needed, remove it to free up space and reduce write overhead:

db.users.dropIndex("email_1")

To drop all indexes except _id:

db.users.dropIndexes()

Always test index removal in a staging environment first. Removing a critical index can cause severe performance degradation.

Step 13: Monitor Index Usage

To see which indexes are being used by your queries, enable the database profiler:

db.setProfilingLevel(1, { slowms: 5 })

This logs queries slower than 5ms. Then check the system profile:

db.system.profile.find().sort({ ts: -1 }).limit(5)

Look for the planSummary field to identify which index was used (e.g., IXSCAN { email: 1 }).

Alternatively, use MongoDB Compass or MongoDB Atlas Performance Advisor to visualize index usage over time.

Best Practices

Index Only What You Need

Every index consumes memory and slows down write operations (insert, update, delete). MongoDB must update all indexes on a document change. Avoid creating indexes just in case. Instead, base your indexing strategy on actual query patterns.

Order Matters in Compound Indexes

Place the most selective field (highest cardinality) first in compound indexes. For example, if email is unique and status has only 3 possible values, index as { email: 1, status: 1 }, not the reverse.

Use Covered Queries

A covered query is one where all fields in the query and projection are part of the index. MongoDB can satisfy the query using only the index, without touching the documents.

Example:

db.users.createIndex({ email: 1, name: 1 })
db.users.find({ email: "john@example.com" }, { name: 1, _id: 0 })

Here, the index contains both the filter field (email) and the returned field (name). The query is covered and executes faster.

Avoid Over-Indexing

Too many indexes can degrade write performance and consume excessive RAM. MongoDB loads indexes into memory (WiredTiger cache). If indexes exceed available RAM, performance drops due to disk I/O.

As a rule of thumb: aim for 510 indexes per collection unless you have complex query requirements.

Use Index Filters for Complex Queries

When queries involve multiple possible indexes, use the $hint operator to force MongoDB to use a specific index:

db.users.find({ country: "USA", status: "active" }).hint({ country: 1, status: 1 })

This is useful during performance tuning or when the query planner chooses a suboptimal index.

Rebuild Indexes Periodically

Over time, indexes can become fragmented due to frequent updates and deletions. Rebuilding indexes can improve performance.

To rebuild all indexes on a collection:

db.users.reIndex()

Use this sparingly in production, as it locks the collection during operation. Schedule during maintenance windows.

Combine Indexes with Aggregation Pipelines

Indexing is equally important for aggregation operations. Ensure your $match stages use indexed fields. For example:

db.orders.aggregate([
{ $match: { customerId: "123", status: "shipped" } },
{ $group: { _id: "$productId", total: { $sum: "$amount" } } }
])

Ensure a compound index exists on { customerId: 1, status: 1 }.

Monitor Index Size and Memory Usage

Use the following command to see index sizes:

db.users.stats()

Look for the indexSizes field. If indexes consume more than 50% of available RAM, consider optimizing or reducing them.

Test Indexes in Staging

Always test index creation and removal in a staging environment that mirrors production data volume and query patterns. Use tools like mongorestore to replicate data before testing.

Use Atlas Performance Advisor

If youre using MongoDB Atlas, enable the Performance Advisor. It automatically suggests missing indexes based on slow queries and provides recommendations with one-click creation.

Tools and Resources

MongoDB Compass

MongoDB Compass is the official GUI for MongoDB. It provides a visual interface to create, analyze, and drop indexes. The Indexes tab shows all indexes on a collection, their size, and usage statistics. You can also simulate queries and see which index is used.

MongoDB Atlas

Atlas is MongoDBs fully managed cloud database service. It includes advanced monitoring, automated indexing suggestions, and performance tuning tools. The Performance Advisor is particularly valuable for teams without dedicated DBAs.

mongosh (MongoDB Shell)

The modern replacement for the legacy mongo shell, mongosh is a JavaScript-based CLI with enhanced features, syntax highlighting, and better error reporting. Use it for scripting and automation.

Database Profiler

Enable profiling with db.setProfilingLevel() to log slow queries and analyze index usage. Set the level to 1 to log queries slower than a threshold, or 2 to log all queries.

Third-Party Monitoring Tools

• Prometheus + Grafana: Monitor MongoDB metrics like index hit rate, cache usage, and query latency.
• Datadog: Offers MongoDB integration with pre-built dashboards for index performance.
• New Relic: Tracks slow queries and provides index recommendations.

Official Documentation

Always refer to the official MongoDB documentation for version-specific behavior:

• MongoDB Indexes
• Compound Indexes
• Text Indexes
• Geospatial Indexes

Learning Resources

• MongoDB University: Free courses like MongoDB Indexing and Performance Tuning
• YouTube Channels: MongoDB, MongoDB Developer
• Books: MongoDB in Action by Kyle Banker, The Definitive Guide to MongoDB by Simon Howes

Real Examples

Example 1: E-Commerce Product Search

Scenario: You run an e-commerce platform with a products collection. Users frequently search by category and price range.

Sample document:

{
_id: ObjectId("..."),
name: "Wireless Headphones",
category: "Electronics",
price: 99.99,
brand: "Sony",
inStock: true
}

Common queries:

db.products.find({ category: "Electronics", price: { $lt: 150 } })
db.products.find({ brand: "Sony", inStock: true }).sort({ price: 1 })

Recommended indexes:

db.products.createIndex({ category: 1, price: 1 })
db.products.createIndex({ brand: 1, inStock: 1, price: 1 })

These indexes cover both filtering and sorting. The second index supports the sort on price because its the last field in the index.

Example 2: User Activity Log

Scenario: You store user login events in a logs collection. You need to find recent activity for a specific user.

Sample document:

{
userId: "u789",
action: "login",
timestamp: ISODate("2024-05-10T10:30:00Z"),
ip: "192.168.1.1"
}

Common query:

db.logs.find({ userId: "u789" }).sort({ timestamp: -1 }).limit(10)

Recommended index:

db.logs.createIndex({ userId: 1, timestamp: -1 })

This compound index allows MongoDB to quickly locate all logs for a user and return them in descending timestamp order without additional sorting.

Example 3: Blog Platform with Text Search

Scenario: A blog with articles that users search by keywords.

Sample document:

{
title: "How to Create MongoDB Index",
content: "Creating indexes in MongoDB improves query performance...",
tags: ["mongodb", "database", "indexing"],
author: "Alex Rivera",
published: true
}

Recommended index:

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

Query:

db.articles.find({ $text: { $search: "MongoDB performance" } })

Use $meta to sort by relevance score:

db.articles.find(
{ $text: { $search: "MongoDB performance" } },
{ score: { $meta: "textScore" } }
).sort({ score: { $meta: "textScore" } })

Example 4: Location-Based Service

Scenario: A food delivery app needs to find nearby restaurants.

Sample document:

{
name: "Pizza Palace",
location: {
type: "Point",
coordinates: [-73.9857, 40.7484]
},
cuisine: "Italian",
open: true
}

Index:

db.restaurants.createIndex({ location: "2dsphere" })

Query:

db.restaurants.find({
location: {
$near: {
$geometry: {
type: "Point",
coordinates: [-73.99279, 40.719296]
},
$maxDistance: 5000
}
},
open: true
})

For better performance, create a compound index:

db.restaurants.createIndex({ location: "2dsphere", open: 1 })

FAQs

Do indexes slow down writes?

Yes. Every time you insert, update, or delete a document, MongoDB must update all indexes that include the modified fields. This adds overhead. However, the performance gain on reads usually outweighs this costespecially when queries are frequent.

How many indexes can a collection have?

MongoDB allows up to 64 indexes per collection. However, its not recommended to approach this limit. More indexes mean higher memory usage and slower writes.

Can I create an index on a nested field?

Yes. Use dot notation. For example, if you have a document like { address: { city: "NYC" } }, create an index with:

db.users.createIndex({ "address.city": 1 })

Whats the difference between a sparse and a partial index?

A sparse index only includes documents that have the indexed field, regardless of the fields value. A partial index includes documents that match a filter conditioneven if the field is missing, as long as the condition is met. Partial indexes are more flexible and powerful.

Should I index every field I query?

No. Index only the fields used in filters, sorts, or projections. Indexing every field leads to unnecessary overhead. Use the explain() method to verify whether an index is being used.

Can I create an index on an array field?

Yes. MongoDB indexes each element of the array individually. This is called a multikey index. For example, if a document has tags: ["mongodb", "index"], MongoDB creates index entries for both values.

How do I know if an index is effective?

Use explain("executionStats") to check:

• Does it use IXSCAN instead of COLLSCAN?
• Is the number of documents examined low?
• Is the query time significantly reduced?

What happens if I create a duplicate index?

MongoDB will ignore it and return a success message, but no new index is created. You can check existing indexes with getIndexes() to avoid duplication.

Do I need to restart MongoDB after creating an index?

No. Index creation is online by default in MongoDB 4.2+. The database continues to accept reads and writes during index creation, though performance may temporarily degrade.

Are indexes automatically created on foreign keys?

No. Unlike relational databases, MongoDB does not enforce referential integrity or auto-create indexes on referenced fields. You must manually create indexes on fields used for joins or lookups in aggregation pipelines.

Conclusion

Creating MongoDB indexes is not a one-time setupits an ongoing optimization process. As your application evolves, so do your query patterns. Regularly analyzing slow queries, monitoring index usage, and refining your index strategy are essential to maintaining high performance at scale.

Remember: indexes are not a silver bullet. They improve read performance at the cost of write overhead and memory usage. The goal is not to create as many indexes as possible, but to create the right onesthe ones that directly support your most critical and frequent operations.

Start by identifying your slowest queries. Use explain() to understand how MongoDB executes them. Then build targeted indexessingle field, compound, text, geospatial, or partialbased on actual usage. Test thoroughly in staging. Monitor in production. Iterate.

With disciplined indexing practices, youll transform MongoDB from a slow, unpredictable data store into a high-performance engine that scales seamlessly with your business. Mastering indexes is not just a technical skillits a competitive advantage in the world of data-driven applications.