MongoDB Tutorial — Documents, Queries, Indexes, and Aggregation Pipeline

Introduction

Learn MongoDB with practical Node.js and Python examples. Covers CRUD operations, aggregation pipeline, indexing strategies, schema design, and when to use MongoDB vs PostgreSQL.

Why This Matters

Understanding this technology deeply helps you make better architectural decisions, debug faster, and build more reliable systems. This guide focuses on practical patterns used in production environments.

Core Concepts

• Fundamentals — The essential concepts you must understand before moving to advanced usage
• Setup and Configuration — Best-practice configuration for development and production
• Common Patterns — Industry-standard patterns that cover the majority of real-world use cases
• Debugging and Monitoring — How to observe what's happening and diagnose problems

Getting Started

Install the required dependencies and configure your environment. The setup process is straightforward for most use cases.

Core Implementation

The fundamental patterns you need to implement working solutions. These examples are production-tested and handle edge cases correctly.

Advanced Patterns

Once the basics work, these patterns address the challenges that arise in real production systems: concurrency, error handling, monitoring, and scale.

Performance Tuning

Default configurations work for most cases but understanding the key performance levers lets you optimize for your specific workload.

Security Considerations

Security is not optional. These patterns ensure your implementation follows the principle of least privilege and handles sensitive data correctly.

Troubleshooting

When things break, a systematic approach saves time. These are the most common failure modes and how to diagnose each one.

Frequently Asked Questions

Is this production-ready?

Yes, with proper configuration, monitoring, and testing. Follow the patterns in this guide and adapt to your specific requirements.

What are the alternatives?

Several alternatives exist with different trade-offs. The right choice depends on your team's experience, scale requirements, and existing infrastructure.

What is MongoDB?

MongoDB is a NoSQL document database that stores data in flexible, JSON-like BSON format. It's ideal for applications that need schema flexibility, horizontal scaling, or high write throughput.

Core Concepts

• Document: Basic unit of data (like a row)
• Collection: Group of documents (like a table)
• Database: Group of collections
• _id: Unique identifier (auto-generated ObjectId)

Basic Operations (CRUD)

// Create
db.users.insertOne({ name: "John", email: "[email protected]" });
db.users.insertMany([{...}, {...}]);

// Read
db.users.findOne({ _id: ObjectId("...") });
db.users.find({ age: { $gte: 18 } });
db.users.find({ status: "active" }).sort({ createdAt: -1 }).limit(10);

// Update
db.users.updateOne(
  { _id: ObjectId("...") },
  { $set: { status: "inactive" } }
);
db.users.updateMany(
  { age: { $lt: 18 } },
  { $set: { isMinor: true } }
);

// Delete
db.users.deleteOne({ _id: ObjectId("...") });
db.users.deleteMany({ status: "deleted" });

Indexing

// Single field index
db.users.createIndex({ email: 1 });

// Compound index
db.orders.createIndex({ userId: 1, createdAt: -1 });

// Text index
db.posts.createIndex({ title: "text", content: "text" });

// View indexes
db.users.getIndexes();

Aggregation Pipeline

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $group: { 
      _id: "$customerId",
      total: { $sum: "$amount" },
      count: { $sum: 1 }
  }},
  { $sort: { total: -1 } },
  { $limit: 10 }
]);

Schema Design Tips

• Embed: When data is accessed together (user + profile)
• Reference: When data grows independently (user + orders)
• Denormalize: For read-heavy workloads (store computed values)

Frequently Asked Questions

MongoDB vs SQL?

Use MongoDB for flexible schemas, horizontal scaling, or document-oriented data. Use SQL for complex queries, transactions, or structured data.

How do I handle relationships?

Use references (store _id) for one-to-many, embed for one-to-one or small arrays.