New content added weeklyLive

Master MongoDB with Adaptive AI.

Master MongoDB across 29 topics - Foundations, Aggregation and Data Modelling, and Advanced MongoDB - guided by Leyaa's adaptive intelligence.

3Parts

29Topics

240Patterns

60hEst. duration

Start Learning Free

MongoDB Course

3 - part learning journey

Foundations

11 topics · 88 patterns

Beginner

Aggregation and Data Modelling

9 topics · 79 patterns

Intermediate

Advanced MongoDB

9 topics · 73 patterns

Advanced

Begin Part 1: Foundations

✦ Course Structure

Your MongoDB Journey in 3 Parts

Each part builds on the last - a deliberate progression from beginner to advanced.

Beginner

Part 1: Foundations

Covers MongoDB Fundamentals, MongoDB vs SQL Mental Model, Document Structure and 8 more topics.

11Topics

88Patterns

View topics

Intermediate

Part 2: Aggregation and Data Modelling

Covers Aggregation Pipeline Fundamentals, Aggregation Operators, Advanced Aggregation Stages and 6 more topics.

9Topics

79Patterns

View topics

Advanced

Part 3: Advanced MongoDB

Covers Transactions, Read and Write Concerns, Replication Concepts and 6 more topics.

9Topics

73Patterns

View topics

Curriculum

Everything You'll Learn

Explore every topic and pattern in the course.

MongoDB

3 parts · 29 topics · 240 patterns

Part 1: Foundations11 topics · 88 patterns

Beginner

MongoDB Fundamentals

8 patterns

What is MongoDB

Why document databases over relational

How MongoDB stores data as documents

Document model mental model (JSON/BSON)

Collections vs tables mental model

MongoDB installation and setup

MongoDB Shell (mongosh) basics

Database and collection creation

MongoDB vs SQL Mental Model

6 patterns

Why the paradigm shift matters

Tables vs collections thinking

Rows vs documents thinking

Joins vs embedding decision

Normalization vs denormalization default

Transactions vs atomic document writes

Document Structure

9 patterns

Why document design matters

BSON data types overview

String and number types

Boolean and null types

Date and timestamp types

ObjectId and how it is generated

Arrays in documents

Embedded documents (nested objects)

Document size limits and structure rules

Inserting Documents

9 patterns

Why insert operations matter

insertOne method

insertMany method

Auto-generated _id behavior

Custom _id values

Insert with nested documents

Insert with arrays

Ordered vs unordered inserts

Write concern basics

Finding Documents

8 patterns

Why querying is essential

find method basics

findOne method

Query filter syntax

Projection for selecting fields

Excluding fields from results

Pretty printing and cursor behavior

How MongoDB scans documents

Comparison Query Operators

8 patterns

Why query operators are needed

$eq for equality

$ne for not equal

$gt and $gte for greater than

$lt and $lte for less than

$in for matching a set

$nin for not in set

Combining comparison operators

Logical Query Operators

7 patterns

Why logical operators matter

$and operator behavior

$or operator behavior

$not operator behavior

$nor operator behavior

Implicit AND with multiple conditions

Combining logical and comparison operators

Querying Arrays and Embedded Documents

8 patterns

Why querying nested data matters

Querying array elements directly

$all operator for matching all elements

$size operator for array length

$elemMatch for complex array queries

Dot notation for embedded documents

Querying nested fields at any depth

Array of embedded documents queries

Updating Documents

10 patterns

Why updating documents matters

updateOne method

updateMany method

$set operator for setting fields

$unset operator for removing fields

$inc operator for incrementing

$push operator for adding to arrays

$pull operator for removing from arrays

$addToSet for unique array additions

Upsert behavior (update or insert)

Deleting Documents

7 patterns

Why delete operations need care

deleteOne method

deleteMany method

Delete with filter conditions

Delete all documents in collection

Drop collection vs deleteMany

Soft delete pattern in MongoDB

Sorting, Limiting, and Counting

8 patterns

Why result control matters

sort method ascending and descending

Sorting by multiple fields

limit method for pagination

skip method for offset

Pagination pattern with skip and limit

countDocuments method

estimatedDocumentCount for speed

Part 2: Aggregation and Data Modelling9 topics · 79 patterns

Intermediate

Aggregation Pipeline Fundamentals

9 patterns

Why the aggregation pipeline is needed

Pipeline mental model (stages flow)

$match stage for filtering

$project stage for shaping output

$group stage for aggregation

$sort stage for ordering

$limit and $skip stages

Pipeline execution order matters

How the engine optimizes pipelines

Aggregation Operators

8 patterns

Why aggregation operators matter

$sum accumulator

$avg accumulator

$min and $max accumulators

$count accumulator

$first and $last accumulators

$push accumulator for building arrays

$addToSet accumulator for unique arrays

Advanced Aggregation Stages

9 patterns

Why advanced stages matter

$unwind for flattening arrays

$lookup for joining collections

$lookup with pipeline (advanced join)

$addFields for computed fields

$replaceRoot for restructuring

$facet for multiple pipelines

$bucket and $bucketAuto for distribution

$out and $merge for writing results

Aggregation Expressions

8 patterns

Why expressions matter in pipelines

String expressions ($concat, $toUpper, $toLower)

Arithmetic expressions ($add, $multiply, $divide)

Date expressions ($year, $month, $dayOfMonth)

Conditional expressions ($cond, $switch)

Array expressions ($size, $arrayElemAt, $filter)

Type conversion expressions ($toInt, $toString)

Comparison expressions ($eq, $gt in aggregation)

Indexing Fundamentals

9 patterns

Why indexes are critical for performance

How MongoDB indexes work (B-tree mental model)

createIndex method

Single field index

Compound index and field order

Index direction (ascending vs descending)

Unique index behavior

explain method for query analysis

Index usage verification

Advanced Indexing

9 patterns

Why advanced indexing matters

Multikey indexes for arrays

Text indexes for search

Sparse indexes

Partial indexes with filter

TTL indexes for auto-expiry

Covered queries with indexes

Index intersection behavior

When not to index

Schema Design Patterns

9 patterns

Why schema design matters in MongoDB

Embedding vs referencing decision

One-to-one embedding pattern

One-to-many embedding pattern

One-to-many referencing pattern

Many-to-many with references

Denormalization trade-offs

Schema design for read-heavy workloads

Schema design for write-heavy workloads

Data Modeling Best Practices

8 patterns

Why modeling decisions matter

Document size and growth patterns

Bucket pattern for time-series data

Attribute pattern for variable fields

Subset pattern for large documents

Computed pattern for pre-aggregation

Anti-patterns to avoid

Schema versioning strategies

Update Operators in Depth

10 patterns

Why advanced updates matter

$rename operator for field names

$min and $max update operators

$mul operator for multiplication

Array update with positional $ operator

Array update with $[] all positional

Array update with $[identifier] filtered

$each modifier with $push

$slice modifier with $push

Bulk write operations

Part 3: Advanced MongoDB9 topics · 73 patterns

Advanced

Transactions

9 patterns

Why transactions are needed in MongoDB

Single document atomicity

Multi-document transactions

Session and transaction syntax

Commit and abort behavior

Transaction isolation in MongoDB

Read concern and write concern in transactions

Transaction performance considerations

When transactions are necessary vs unnecessary

Read and Write Concerns

7 patterns

Why consistency levels matter

Write concern levels (w: 1, majority)

Read concern levels (local, majority, snapshot)

Read preference for replica sets

Causal consistency concept

Tuning consistency vs performance

Write concern and data durability

Replication Concepts

8 patterns

Why replication is needed

Replica set architecture mental model

Primary and secondary nodes

Automatic failover behavior

Election process concept

Oplog and replication mechanism

Read from secondaries trade-offs

Replica set configuration basics

Sharding Concepts

8 patterns

Why sharding is needed

Horizontal scaling mental model

Shard key selection importance

Range-based sharding

Hash-based sharding

Chunks and balancer concept

Mongos router behavior

Choosing a good shard key

Change Streams

8 patterns

Why change streams are needed

Watch method for real-time updates

Change stream events (insert, update, delete)

Resume tokens for reliability

Change streams on collections

Change streams on databases

Change stream pipelines for filtering

Use cases for change streams

Security

9 patterns

Why MongoDB security matters

Authentication mechanisms

Creating users and roles

Built-in roles (read, readWrite, dbAdmin)

Custom role creation

Role-based access control

Network security and bind IP

Encryption at rest concept

Audit logging basics

Performance Optimization

8 patterns

Why performance tuning matters

Profiler for slow queries

Explain plan analysis (queryPlanner, executionStats)

Identifying missing indexes

Query patterns that cause collection scans

Projection for reducing data transfer

Connection pooling concept

Memory and storage engine basics (WiredTiger)

MongoDB Atlas and Cloud

8 patterns

Why managed databases matter

Atlas cluster creation basics

Atlas connection string setup

Atlas search overview

Atlas triggers overview

Atlas data federation concept

Backup and restore strategies

Monitoring with Atlas metrics

Advanced Query Patterns

8 patterns

Why query patterns matter

Text search with text indexes

Geospatial queries basics

Regex queries in MongoDB

Graph lookup for recursive data

Aggregation for reporting dashboards

Time-series collections

Capped collections for fixed-size data

Why Leyaa

Not just a course. A learning intelligence.

Leyaa doesn't just deliver content - it understands where you are, what you need, and how to get you there fastest.

Adaptive Diagnostics

Leyaa identifies which of the 240 patterns you've mastered and which need work - before you waste time on what you already know.

Pattern-Level Precision

Every pattern gets a verdict - Learn, Practice, or Skip - so your study time goes exactly where it counts.

Intelligent Pacing

Leyaa reads your velocity across the whole course and adapts your focus list dynamically, keeping you in the optimal learning zone.

Before & After Visibility

Every assessment creates a snapshot. Retake anytime to see exactly how much you've grown - topic by topic, pattern by pattern.

Learner Autonomy

Leyaa recommends, never restricts. Override any suggestion and explore at your own pace - the system tracks everything regardless.

Clear Learning Path

Foundations → Aggregation and Data Modelling → Advanced MongoDB - a structured journey where each part sets you up perfectly for the next.

MongoDB

Ready to master MongoDB?
Start your journey today

Start your diagnostic now. Build mastery across all 29 topics in under 15 minutes.

29 Topics

240 Patterns

Personalized roadmap

Master MongoDB with Adaptive AI.

Your MongoDB Journey in 3 Parts

Everything You'll Learn

MongoDB

Not just a course. A learning intelligence.

Ready to master MongoDB?Start your journey today

Ready to master MongoDB?
Start your journey today