Skip to main content

Learning path

MongoDB learning path: everything to study, topic by topic

Comprehensive MongoDB / NoSQL assessment covering the document model, CRUD operations, query operators, indexing strategies, aggregation pipelines, schema design patterns, replication, sharding, transactions, security, and production performance tuning.

Short answer

To learn MongoDB, work through 6 modules and 22 topics in the order they build on each other. It starts with Document Basics, then moves on to CRUD & Queries and Indexing & Aggregation. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
22
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Document Basics4 topics
  • Document Model

    JSON/BSON document structure, flexible schema, nested documents, arrays, document size limits (16 MB), comparison with relational tables

    Objectives

    • Understand the MongoDB document model and its advantages
    • Compare document-based storage with relational models

    Key concepts

    • JSON document structure
    • flexible schema
    • nested documents
    • arrays in documents
    • 16 MB document limit
    • documents vs rows
    • collections vs tables
    • NoSQL vs SQL paradigm
  • BSON Types

    BSON data types (String, Int32, Int64, Double, Decimal128, Boolean, Date, ObjectId, Array, Binary, Null, Regex, Timestamp), type comparison and ordering

    Objectives

    • Identify and use BSON data types correctly
    • Understand ObjectId structure and generation

    Key concepts

    • ObjectId structure
    • String type
    • numeric types (Int32, Int64, Double, Decimal128)
    • Date and Timestamp
    • Boolean and Null
    • Binary data
    • BSON type codes
    • type comparison order
  • Collections & Databases

    Creating and dropping databases and collections, capped collections, views, collation, namespace limits, system collections

    Objectives

    • Create and manage databases and collections
    • Understand capped collections and views

    Key concepts

    • creating databases implicitly
    • creating collections
    • capped collections
    • views
    • collation settings
    • namespace limits
    • system.* collections
    • database commands
  • mongosh Basics

    MongoDB Shell commands, connecting to instances, switching databases, running queries, scripting in mongosh, helper methods, connection strings

    Objectives

    • Connect to MongoDB and navigate databases using mongosh
    • Execute basic commands and queries in the shell

    Key concepts

    • mongosh connection strings
    • use database command
    • show dbs / show collections
    • db.collection syntax
    • helper methods
    • scripting in mongosh
    • mongosh vs legacy mongo shell
    • connection options
2 · CRUD & Queries5 topics
  • Insert Operations

    insertOne, insertMany, ordered vs unordered inserts, write concern, auto-generated _id, bulk write operations

    Objectives

    • Insert single and multiple documents correctly
    • Understand ordered vs unordered insert behavior

    Key concepts

    • insertOne()
    • insertMany()
    • ordered vs unordered inserts
    • write concern
    • auto-generated _id
    • bulk write operations
    • insert acknowledgment
    • duplicate key errors
  • Find Queries

    find(), findOne(), projection, cursor methods (sort, limit, skip), dot notation for nested fields, querying arrays, countDocuments

    Objectives

    • Write find queries with projection and cursor modifiers
    • Query nested documents and arrays using dot notation

    Key concepts

    • find() and findOne()
    • projection (inclusion/exclusion)
    • sort()
    • limit() and skip()
    • dot notation
    • array queries
    • countDocuments()
    • cursor iteration
  • Update Operations

    updateOne, updateMany, replaceOne, $set, $unset, $inc, $push, $pull, $addToSet, upsert, array update operators, findOneAndUpdate

    Objectives

    • Perform updates using field and array update operators
    • Understand upsert semantics and atomic modifications

    Key concepts

    • updateOne() / updateMany()
    • replaceOne()
    • $set / $unset
    • $inc / $mul
    • $push / $pull / $addToSet
    • upsert option
    • array filters
    • findOneAndUpdate()
  • Delete Operations

    deleteOne, deleteMany, findOneAndDelete, drop(), TTL indexes for auto-expiry, write concern for deletes

    Objectives

    • Delete documents safely with appropriate filters
    • Understand TTL indexes for automatic document expiration

    Key concepts

    • deleteOne()
    • deleteMany()
    • findOneAndDelete()
    • drop() collection
    • TTL indexes
    • write concern for deletes
    • delete vs drop semantics
    • filter matching for deletes
  • Query Operators

    Comparison ($eq, $gt, $lt, $in, $nin), logical ($and, $or, $not, $nor), element ($exists, $type), evaluation ($regex, $expr), array ($elemMatch, $size, $all)

    Objectives

    • Combine query operators for complex filtering
    • Use array query operators effectively

    Key concepts

    • comparison operators ($eq, $gt, $gte, $lt, $lte, $ne, $in, $nin)
    • logical operators ($and, $or, $not, $nor)
    • element operators ($exists, $type)
    • $regex queries
    • $expr for aggregation expressions in find
    • $elemMatch
    • $size and $all
    • implicit $and behavior
3 · Indexing & Aggregation4 topics
  • Single-Field Indexes

    createIndex, index types (ascending, descending, unique, sparse, partial, TTL), explain() output, index usage analysis, default _id index

    Objectives

    • Create and analyze single-field indexes
    • Interpret explain() output for query optimization

    Key concepts

    • createIndex()
    • ascending/descending indexes
    • unique indexes
    • sparse indexes
    • partial indexes
    • TTL indexes
    • explain() plans
    • default _id index
  • Compound & Specialized Indexes

    Compound indexes, ESR rule (equality-sort-range), multikey indexes, text indexes, geospatial indexes (2dsphere), hashed indexes, wildcard indexes, index intersection

    Objectives

    • Design compound indexes following the ESR rule
    • Choose the correct specialized index type for each use case

    Key concepts

    • compound index field order
    • ESR rule (equality-sort-range)
    • multikey indexes
    • text indexes
    • 2dsphere indexes
    • hashed indexes
    • wildcard indexes
    • index intersection
  • Aggregation Pipeline

    Pipeline stages ($match, $group, $project, $sort, $limit, $skip, $unwind, $lookup), accumulators ($sum, $avg, $min, $max, $push), pipeline optimization

    Objectives

    • Build multi-stage aggregation pipelines
    • Use $lookup for cross-collection joins

    Key concepts

    • $match stage
    • $group stage and accumulators
    • $project / $addFields
    • $sort / $limit / $skip
    • $unwind
    • $lookup (left outer join)
    • $sum / $avg / $min / $max
    • pipeline stage ordering
  • Advanced Aggregation

    $facet, $bucket, $graphLookup, $merge, $out, $replaceRoot, $redact, window functions, aggregation expressions, aggregation performance

    Objectives

    • Use advanced aggregation stages for complex data transformations
    • Build materialized views with $merge

    Key concepts

    • $facet for multi-faceted results
    • $bucket / $bucketAuto
    • $graphLookup for recursive queries
    • $merge / $out for materialized views
    • $replaceRoot / $replaceWith
    • $redact for document-level security
    • window functions ($setWindowFields)
    • aggregation performance tuning
4 · Schema & Data Modeling4 topics
  • Embedding vs Referencing

    Embedding (denormalization) vs referencing (normalization), one-to-one, one-to-many, many-to-many relationships, data duplication trade-offs, read vs write optimization

    Objectives

    • Choose between embedding and referencing based on access patterns
    • Design schemas that balance read performance and data consistency

    Key concepts

    • embedding (denormalization)
    • referencing (normalization)
    • one-to-one relationships
    • one-to-many relationships
    • many-to-many relationships
    • data duplication trade-offs
    • read vs write optimization
    • document growth and padding
  • Schema Design Patterns

    Attribute pattern, bucket pattern, outlier pattern, computed pattern, subset pattern, extended reference pattern, polymorphic pattern, schema versioning pattern

    Objectives

    • Apply established schema design patterns to real-world problems
    • Identify when to use each schema pattern based on workload

    Key concepts

    • attribute pattern
    • bucket pattern
    • outlier pattern
    • computed pattern
    • subset pattern
    • extended reference pattern
    • polymorphic pattern
    • schema versioning pattern
  • Schema Validation

    JSON Schema validation, validation rules ($jsonSchema), validation levels (strict, moderate), validation actions (error, warn), collMod for existing collections

    Objectives

    • Define schema validation rules using $jsonSchema
    • Choose appropriate validation levels and actions

    Key concepts

    • $jsonSchema validator
    • required fields
    • bsonType constraints
    • enum values
    • validation level (strict vs moderate)
    • validation action (error vs warn)
    • collMod command
    • additionalProperties control
  • Multi-Document Transactions

    ACID transactions in MongoDB, startSession, startTransaction, commitTransaction, abortTransaction, read/write concerns in transactions, transaction limits, retryable writes

    Objectives

    • Implement multi-document transactions correctly
    • Understand when transactions are necessary vs schema redesign

    Key concepts

    • ACID properties in MongoDB
    • startSession() / startTransaction()
    • commitTransaction() / abortTransaction()
    • read concern in transactions
    • write concern in transactions
    • transaction time limit (60s default)
    • retryable writes
    • when to use vs avoid transactions
5 · Replication & Sharding2 topics
  • Replica Sets

    Replica set architecture, primary/secondary/arbiter roles, elections, oplog, read preferences, write concern levels, automatic failover, rs.initiate()

    Objectives

    • Configure and manage replica sets for high availability
    • Choose appropriate read preferences and write concerns

    Key concepts

    • primary/secondary/arbiter roles
    • replica set elections
    • oplog (operations log)
    • read preferences (primary, secondary, nearest)
    • write concern (w:1, w:majority, w:0)
    • automatic failover
    • rs.initiate() / rs.add()
    • replica set member priorities
  • Sharding

    Horizontal scaling, shard key selection, ranged vs hashed sharding, mongos router, config servers, chunks, balancer, sh.shardCollection()

    Objectives

    • Design sharding strategies with appropriate shard keys
    • Understand the impact of shard key choice on query performance

    Key concepts

    • shard key selection criteria
    • ranged vs hashed sharding
    • mongos query router
    • config servers
    • chunks and chunk splitting
    • balancer process
    • scatter-gather queries
    • zone sharding
6 · Production & Security3 topics
  • Backup & Recovery

    mongodump/mongorestore, filesystem snapshots, point-in-time recovery, MongoDB Atlas backup, oplog-based backup, continuous backup, backup strategies

    Objectives

    • Plan and execute MongoDB backup strategies
    • Perform point-in-time recovery from backups

    Key concepts

    • mongodump / mongorestore
    • filesystem snapshots
    • point-in-time recovery
    • Atlas continuous backup
    • oplog-based incremental backup
    • backup consistency
    • replica set backup strategies
    • sharded cluster backup
  • Security & Authentication

    SCRAM authentication, x.509 certificates, LDAP integration, role-based access control (RBAC), built-in roles, custom roles, TLS/SSL encryption, audit logging, field-level encryption

    Objectives

    • Configure authentication and authorization for MongoDB
    • Implement encryption in transit and at rest

    Key concepts

    • SCRAM authentication
    • x.509 certificate auth
    • LDAP / Kerberos integration
    • built-in roles (read, readWrite, dbAdmin, etc.)
    • custom roles
    • TLS/SSL encryption in transit
    • field-level encryption (FLE / CSFLE)
    • audit logging
  • Performance Tuning

    Query profiler, slow query analysis, currentOp, serverStatus, mongostat, mongotop, connection pooling, WiredTiger cache tuning, Atlas performance advisor

    Objectives

    • Diagnose and resolve MongoDB performance bottlenecks
    • Use profiling tools to optimize query patterns

    Key concepts

    • database profiler (levels 0/1/2)
    • slow query log analysis
    • currentOp() / killOp()
    • serverStatus / dbStats / collStats
    • mongostat / mongotop
    • connection pooling tuning
    • WiredTiger cache configuration
    • Atlas Performance Advisor

Levels: Junior, Mid, and Senior

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying MongoDB?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying MongoDB?

Start with Document Basics: Document Model, BSON Types, and Collections & Databases. The map orders topics by what they depend on, so each one prepares the next.

How long does a full MongoDB assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.