MongoDB Training

You can explain document data models and set up a local MongoDB instance with Compass.

1. What NoSQL is and why it exists90 min
   • CAP theorem trade-offs
   • horizontal versus vertical scaling
   • schema rigidity in relational systems
   • BASE properties versus ACID
   • partition tolerance in distributed clusters
2. Document databases versus relational90 min
   • normalization versus denormalization
   • JSON structure in data storage
   • handling sparse attributes
   • join cost trade-offs
   • application-side data assembly
3. When to choose MongoDB90 min
   • high-velocity ingestion use cases
   • content management systems
   • catalogs with evolving attributes
   • hierarchical data without fixed columns
   • anti-patterns for document stores
4. Documents, collections and BSON90 min
   • Binary JSON type system
   • ObjectIds and timestamp generation
   • embedded subdocuments
   • document size limits
   • data types in BSON versus JSON
5. Installing MongoDB and Compass90 min
   • mongod service lifecycle
   • connection strings and URI format
   • GUI navigation in Compass
   • managing local database files
   • service configuration via mongod.conf
6. The MongoDB Shell REPL environment90 min
   • mongosh startup flags
   • evaluating JavaScript in the shell
   • inspecting server status variables
   • multiline shell editing
   • customizing shell prompt output

Hands-on project: Install MongoDB 7.0 and MongoDB Compass locally, seed a test collection with 1,000 JSON documents, and verify collection stats.

You can write full CRUD queries using the MongoDB shell and Compass to manipulate documents.

1. Inserting documents90 min
   • db.collection.insertOne()
   • db.collection.insertMany()
   • ordered versus unordered inserts
   • write acknowledgment configuration
   • handling duplicate key errors
2. Reading and filtering with find90 min
   • db.collection.find()
   • equality match predicates
   • cursor iteration in the shell
   • cursor methods limit() and sort()
   • pretty printing output
3. Updating documents90 min
   • db.collection.updateOne()
   • db.collection.updateMany()
   • $set operator
   • $inc and $push atomic updates
   • upsert option configuration
4. Deleting documents90 min
   • db.collection.deleteOne()
   • db.collection.deleteMany()
   • drop collection safety checks
   • handling collection renames
   • reclaiming storage space with compact
5. The MongoDB shell and Compass90 min
   • mongosh REPL commands
   • visual query builder in Compass
   • exporting query results to JSON and CSV
   • inspecting schema visualization
   • saving favorite queries in Compass
6. Write concern and atomic modifications90 min
   • findAndModify command
   • returnDocument options
   • writeConcern w:1 versus w:majority
   • journaling commit flags
   • handling write timeout errors

Hands-on project: Write a shell script containing insertOne, insertMany, find with query filters, updateOne with atomic operators, and deleteMany with safety checks.

You can query nested structures, arrays, and build paginated result sets with projection filters.

1. Comparison and logical operators90 min
   • $gt, $lt, $in, $nin
   • $and, $or, $not, $nor
   • query precedence rules
   • type checking with $type
   • checking field existence with $exists
2. Querying arrays and embedded documents90 min
   • $elemMatch operator
   • dot notation for nested fields
   • array exact-match semantics
   • $all array operator
   • $size operator for array length
3. Projection and shaping results90 min
   • inclusion and exclusion flags
   • $slice operator for arrays
   • reducing network payload
   • projecting embedded document fields
   • suppressing the _id field
4. Sorting, skip and limit90 min
   • .sort() memory limits (32MB restriction)
   • .skip() performance pitfalls on large offsets
   • .limit() batch sizing
   • cursor batch management
   • sorting by nested fields
5. Pagination patterns90 min
   • range-based pagination (keyset pagination)
   • cursor stability during concurrent writes
   • infinite scroll query design
   • sorting on indexed fields for keyset queries
   • avoiding offset degradation
6. Evaluation operators and regex90 min
   • $regex for pattern matching
   • $expr for cross-field comparisons
   • $where operator limitations
   • text search regex alternatives
   • optimizing regex queries with anchored prefixes

Hands-on project: Build an e-commerce product catalog search query using comparison operators, element match on array fields, and limit/skip pagination.

You can diagnose slow queries with explain() and design compound indexes for optimal throughput.

1. How indexes work in MongoDB90 min
   • B-tree data structure implementation
   • WiredTiger storage engine cache usage
   • index scan versus collection scan
   • index memory footprint
   • disk I/O impact of missing indexes
2. Single-field and compound indexes90 min
   • Equality, Sort, Range (ESR) rule
   • multikey index creation
   • index cardinality principles
   • compound index key ordering
   • partial index filtering
3. Multikey and text indexes90 min
   • indexing array fields
   • full-text search basics with $text
   • language weights and stemming
   • wildcard index definitions
   • compound multikey restrictions
4. explain() and query plans90 min
   • executionStats mode output
   • totalDocsExamined versus nReturned ratio
   • winning plan selection mechanics
   • rejected plans inspection
   • query optimizer profiling
5. Indexing for performance90 min
   • identifying unused indexes via system.profile
   • background index builds versus foreground
   • storage overhead management
   • index rebuild operations
   • monitoring index hit ratios
6. Profiler and slow query analysis90 min
   • db.setProfilingLevel() configuration
   • query time threshold settings
   • interpreting system.profile collection documents
   • identifying COLLSCAN operations under load
   • remediating unindexed query spikes

Hands-on project: Audit a slow query log on a collection of 500k documents, create a compound index matching the query predicate, and verify execution stats with explain('executionStats').

You can construct multi-stage aggregation pipelines for data transformation, grouping, and analytical queries.

1. The aggregation pipeline120 min
   • pipeline stage execution model
   • streaming data processing architecture
   • expression operators syntax
   • pipeline stage ordering principles
   • debugging individual pipeline stages
2. match, project, group and sort120 min
   • $match stage early filtering optimization
   • $project field shaping and computed fields
   • $group accumulator operators ($sum, $avg, $push, $addToSet)
   • $sort stage memory limits
   • accumulators over array fields
3. lookup, unwind and joins120 min
   • $lookup stage for collection joins
   • $unwind for array flattening
   • correlated subqueries within $lookup
   • handling unmatched documents with let and pipeline
   • performance cost of cross-collection joins
4. Bucketing, faceting and expressions120 min
   • $bucket and $bucketAuto for data segmentation
   • $facet for multi-faceted search results in one pass
   • conditional operators ($cond, $switch, $ifNull)
   • string manipulation operators
   • date arithmetic expressions
5. Real analytical pipelines120 min
   • $out and $merge stages for persisting results
   • pipeline optimization tips and index usage
   • allowDiskUse configuration for large sorts
   • writing reusable pipeline fragments
   • profiling aggregation execution time
6. Advanced stage operations120 min
   • $addFields and $set stage usage
   • $redact for document-level security filtering
   • $graphLookup for recursive hierarchy traversal
   • $sample for random document selection
   • memory pressure handling in complex pipelines

Hands-on project: Build an analytical reporting pipeline for monthly sales data using $match, $group, $lookup across two collections, and $facet for summary statistics.

You can design production schemas using embedding or referencing based on access patterns and growth limits.

1. Embedding versus referencing120 min
   • 16MB document size limit implications
   • read versus write frequency trade-offs
   • data duplication considerations and consistency
   • atomic update boundaries for embedded data
   • when to switch from embedded to referenced
2. One-to-many and many-to-many relationships120 min
   • bounded versus unbounded arrays
   • child reference pattern design
   • two-way referencing with backreferences
   • joining collections at the application layer
   • handling junction collections in NoSQL
3. Schema design patterns120 min
   • attribute pattern for variable fields
   • bucket pattern for time-series and IoT data
   • subset pattern for working sets
   • computed pattern for pre-aggregated values
   • polymorphic pattern for varied document structures
4. Anti-patterns to avoid120 min
   • massive arrays anti-pattern (>10,000 items)
   • unbounded growth fields without capping
   • over-normalization mirroring relational schemas
   • too many collections anti-pattern
   • frequent schema migrations pitfalls
5. Modelling a real application120 min
   • access pattern worksheet creation methodology
   • schema validation rules with JSON Schema
   • versioning document schemas for backward compatibility
   • documenting schema diagrams for engineering teams
   • handling schema evolution without downtime
6. Time-series collections and capped tables120 min
   • time-series collection optimization in MongoDB 7+
   • automatic data expiration with TTL indexes
   • capped collections configuration for logs
   • granularity and bucket sizing for time-series
   • querying historical time-series data efficiently

Hands-on project: Design a complete schema for a multi-tenant project management tool, documenting embedding vs referencing decisions for tasks, comments, and user assignments.

You can integrate MongoDB into Node.js applications using Mongoose models, validation, and middleware.

1. MongoDB with Node.js90 min
   • mongodb native driver connection pooling
   • error handling during connection drops and reconnects
   • async/await patterns with cursor iteration
   • environment configuration for connection strings
   • handling driver warnings and timeouts
2. Mongoose schemas and models90 min
   • Schema types and schema options
   • automatic timestamps configuration
   • compiling models from schemas
   • schema strict mode options
   • subdocument schemas definition
3. Validation and middleware90 min
   • built-in validators (required, min, max, enum)
   • custom validator functions in Mongoose
   • pre and post hook middleware execution order
   • document lifecycle triggers and error handling
   • query middleware for bulk operations
4. Relationships and population90 min
   • ref configuration in schema definitions
   • .populate() method for fetching references
   • virtual population for reverse references
   • population filtering and projection
   • performance considerations of deep population
5. Building a data layer90 min
   • repository pattern design in Express services
   • handling concurrency errors with version keys (__v)
   • connection teardown in automated tests
   • transaction support in Mongoose
   • handling unique constraint validation errors
6. Plugins and schema modularity90 min
   • writing reusable Mongoose plugins
   • plugin configuration options
   • soft-delete plugin implementation
   • pagination plugins for Mongoose models
   • organizing models in enterprise project structures

Hands-on project: Build an Express and Mongoose data access layer featuring schema validation, pre-save hooks for password hashing, and virtual properties.

You can configure replica sets for high availability and implement ACID transactions across documents.

1. Replica sets and high availability90 min
   • primary and secondary nodes topology
   • election protocol and Raft consensus basics
   • heartbeats and failover timing configuration
   • priority and hidden node settings
   • arbiter nodes placement strategy
2. Read and write concerns90 min
   • w: majority write concern mechanics
   • readConcern levels ('local', 'available', 'majority', 'linearizable')
   • stale reads mitigation on secondaries
   • causal consistency sessions
   • durability guarantees with journal writes
3. Sharding for horizontal scale90 min
   • mongos routers and config servers architecture
   • shard key selection strategies and pitfalls
   • hashed versus ranged sharding
   • chunk migration and balancing process
   • avoiding hot-spotting on monotonic shard keys
4. Multi-document transactions90 min
   • session management with client.startSession()
   • withTransaction callback wrapper pattern
   • conflict handling in distributed transactions
   • transaction size limits and time limits
   • ACID guarantees across multiple collections
5. Reliability in production90 min
   • backup strategies with mongodump and oplog monitoring
   • monitoring oplog window and churn rate
   • disaster recovery planning and restore drills
   • node maintenance and rolling upgrades
   • log rotation and audit log configuration
6. Cluster diagnostics and troubleshooting90 min
   • serverStatus() and dbStats() metrics interpretation
   • diagnosing replication lag issues
   • identifying locked threads and connection spikes
   • network partitioning simulation and recovery
   • using Cloud Manager or Ops Manager tools

Hands-on project: Simulate a replica set locally, test failover behavior, and write a multi-document transaction for an order placement workflow.

You can deploy clusters on MongoDB Atlas and implement vector search for AI semantic applications.

1. MongoDB Atlas in the cloud90 min
   • cluster tier selection (M0 to M40+)
   • IP whitelisting and database users setup
   • peering VPC connections with AWS/GCP/Azure
   • private endpoint configuration
   • multi-region cluster deployment
2. Deploying and managing clusters90 min
   • automated cluster scaling and auto-scaling rules
   • Performance Advisor alerts and recommendations
   • continuous cloud backups and point-in-time restore
   • maintenance window scheduling
   • billing alerts and cost control
3. Atlas Search90 min
   • Apache Lucene engine integration in Atlas
   • fts:search index definition using JSON mappings
   • fuzzy matching, autocomplete, and synonym mapping
   • highlighting search results
   • combining $search with standard aggregation stages
4. Atlas Vector Search for AI and semantic search90 min
   • storing vector embeddings generated from LLMs
   • $vectorSearch aggregation stage configuration
   • cosine similarity, dot product, and Euclidean distance
   • approximate nearest neighbor (ANN) search with HNSW
   • hybrid search combining keyword and vector results
5. Security and compliance90 min
   • encryption at rest using customer-managed keys
   • encryption in transit with TLS/SSL enforcement
   • audit logging of administrative and data actions
   • role-based access control (RBAC) in Atlas
   • SOC 2, HIPAA, and GDPR compliance considerations
6. Atlas triggers and serverless functions90 min
   • database triggers for change streams
   • serverless functions execution in Atlas
   • integrating Atlas Triggers with external APIs
   • event-driven architecture using MongoDB change streams
   • debugging trigger execution logs

Hands-on project: Create a managed cluster on MongoDB Atlas, configure network peering, set up Atlas Search index, and run a vector search query with embedding vectors.

You can test database integration layers, secure database access, and monitor production instances.

1. Testing data layers with memory servers90 min
   • mongodb-memory-server package setup
   • isolated test environment isolation
   • beforeEach and afterEach cleanup hooks
   • mocking database failures in tests
   • seed data fixtures for automated testing
2. Database security hardening90 min
   • SCRAM authentication configuration
   • principle of least privilege for database users
   • disabling unnecessary bindings and ports
   • secrets management with environment variables
   • preventing NoSQL injection vulnerabilities in queries
3. Monitoring, metrics and alerting90 min
   • key MongoDB metrics (connections, memory, operation counters)
   • Prometheus exporter for MongoDB
   • Grafana dashboard setup for database health
   • setting up alerts for high replication lag and memory usage
   • disk space monitoring and alert thresholds
4. CI/CD integration for database schemas90 min
   • version-controlled migration scripts
   • automated index creation during deployment pipelines
   • zero-downtime schema change strategies
   • rollback procedures for failed schema migrations
   • linting Mongoose schemas in CI
5. Operational runbooks and incident response90 min
   • writing effective database runbooks
   • handling sudden connection pool exhaustion
   • diagnosing high CPU usage during peak hours
   • emergency failover escalation procedures
   • post-incident review templates for database outages
6. Cost optimization and resource sizing90 min
   • right-sizing Atlas cluster tiers
   • identifying and purging stale collections
   • compressing WiredTiger storage data
   • analyzing network data transfer costs
   • data lifecycle policies for archiving old records

Hands-on project: Write integration tests for a MongoDB data layer using mongodb-memory-server, implement environment secret management, and set up health checks.

You can plan multi-team data ownership, database migrations from relational systems, and scaling governance.

1. Migrating from relational to MongoDB90 min
   • assessing existing SQL schemas and access patterns
   • translating foreign keys to embedded references or subdocuments
   • building ETL scripts for initial data load
   • dual-write phase implementation during migration
   • validation and reconciliation scripts post-migration
2. Multi-team data ownership and governance90 min
   • bounded contexts in microservices sharing MongoDB
   • database-per-service pattern versus shared database
   • managing shared collections across independent teams
   • schema review processes and pull request gating
   • data dictionary maintenance across engineering groups
3. Data retention, GDPR and compliance90 min
   • implementing right-to-be-forgotten (data erasure) in NoSQL
   • pseudonymization and encryption of sensitive user fields
   • audit trails for data access compliance
   • data residency requirements and multi-region routing
   • handling regulatory data export requests
4. Disaster recovery and business continuity90 min
   • Recovery Point Objective (RPO) and Recovery Time Objective (RTO)
   • testing point-in-time restores in staging environments
   • cross-region disaster recovery replication
   • documenting emergency failover runbooks
   • chaos engineering tests for database resilience
5. Enterprise scaling patterns90 min
   • handling tens of thousands of requests per second
   • read scaling with secondary node routing
   • connection pooling tuning for high-concurrency apps
   • caching strategies with Redis in front of MongoDB
   • handling large-scale data archiving and purging
6. Architecture review and technical decision records90 min
   • writing ADRs (Architectural Decision Records) for database choices
   • defending NoSQL architectural decisions to stakeholders
   • evaluating MongoDB against alternative NoSQL engines
   • cost-benefit analysis of document databases at enterprise scale
   • preparing technical debt remediation plans

Hands-on project: Design a migration plan and dual-write script to transition a relational SQL customer table into a MongoDB document collection without downtime.

You can restore a MongoDB deployment to a chosen point in time and state the data loss.

1. Backup options compared90 min
   • mongodump and mongorestore utilities
   • Filesystem snapshots and LVM snapshots
   • Atlas continuous backup mechanics
   • storage overhead of logical backups
   • backup verification best practices
2. Point-in-time recovery90 min
   • Oplog replay mechanisms
   • choosing the exact restore timestamp
   • consistency across sharded clusters during restore
   • handling idempotent restore runs
   • validating data integrity post-restore
3. Rehearsing the restore90 min
   • restore into an isolated staging environment
   • verifying document counts and checksums
   • measuring Recovery Time Objective (RTO)
   • documenting disaster recovery steps
   • automated drill scheduling
4. Preventing the need90 min
   • role-based access limits for drop commands
   • soft delete design patterns
   • change streams for real-time audit logs
   • enforcing deletion protection rules in Atlas
   • multi-factor approval for production drops
5. Cross-region disaster recovery90 min
   • setting up cross-region replica set members
   • failover testing across cloud regions
   • DNS switching during region outages
   • latency impact on synchronous replication
   • cost trade-offs of multi-region active clusters

Hands-on project: Take logical and snapshot backups of a replica set, simulate an accidental collection drop, restore to a point in time just before it using the oplog, and report the measured recovery time and exact data loss.