MongoDB Database Development and Operations Training Course

Course overview

MongoDB teams need more than the ability to write a find() query. Developers and operations staff must model changing data without creating unbounded documents, build indexes that support real workload patterns, diagnose slow queries, and keep deployments available through failure, maintenance, and growth. This course addresses the practical gap between using MongoDB as an application database and running it as a dependable production service. Participants learn to make design and operating decisions that can be explained to engineering leads, platform teams, and risk owners.

Across five instructor-led days, participants work through MongoDB’s document model, CRUD operations, aggregation pipelines, schema validation, indexing, query plans, transactions, replication, sharding, backup, restore, monitoring, and security controls. They use mongosh to administer databases, MongoDB Compass to inspect data and analyse queries, and MongoDB Atlas to configure managed deployments and operational controls. The course connects each feature to a concrete decision: selecting an embedding or referencing pattern, creating a compound index, configuring a replica set, choosing a shard key, or preparing a recovery procedure.

Teaching combines short technical demonstrations with guided labs built around an evolving order-management dataset. Participants create a working MongoDB solution, optimise representative queries, configure resilience features, and respond to simulated incidents such as a failed node, an inefficient query, and accidental data loss. They leave with a documented MongoDB implementation pack containing a schema design, validation rules, index plan, aggregation queries, deployment topology, backup-and-restore procedure, and operational runbook suitable for adaptation in their own environment.

The course is suited to software developers, database administrators, DevOps engineers, data engineers, and technical leads who need foundation-to-intermediate capability across both MongoDB development and day-to-day operations.

Course objectives

By the end of this course, participants will be able to:

• Design MongoDB document schemas using embedding, referencing, cardinality, and document-growth criteria
• Create and update collections with mongosh using CRUD operations, projections, array updates, and bulk writes
• Build aggregation pipelines with $match, $group, $lookup, $unwind, and $set stages
• Implement JSON Schema validation rules and document appropriate schema-versioning approaches
• Create compound, multikey, text, and partial indexes from measured query requirements
• Interpret explain() output and use query-plan evidence to resolve slow MongoDB queries
• Configure replica set, backup, restore, user-role, and monitoring controls for a production-ready deployment
• Produce a MongoDB implementation pack containing schema, index, topology, recovery, and operational-runbook artefacts

Benefits of attending

Target competencies

Who should attend

• Software Developers — who build services that require durable document models and predictable query performance
• Database Administrators — who need to operate, secure, back up, and recover MongoDB deployments
• DevOps and Platform Engineers — who provision MongoDB environments and support availability, monitoring, and scaling
• Data Engineers — who design aggregation workloads and data-access patterns for operational data stores
• Technical Leads and Solution Architects — who must make defensible MongoDB design and deployment decisions
• Application Support Engineers — who investigate production query, connectivity, replication, and recovery issues

Requirements and prerequisites

Participants should be comfortable using a command line, reading basic JSON documents, and writing simple queries in any database or programming context. Familiarity with concepts such as records, fields, indexes, client-server applications, and basic networking will help. Some exposure to JavaScript syntax is useful because mongosh uses JavaScript, but participants do not need to be application developers. No prior MongoDB administration, replication, sharding, cloud-platform, Linux-server, or database-certification experience is required. Complete beginners should expect a technically practical week with guided exercises rather than a programming course.

Training methodology

The instructor introduces each MongoDB capability through a focused demonstration, then participants apply it in a guided lab using an order-management dataset with customers, products, orders, inventory, and audit events. Exercises progress from document modelling and CRUD work to aggregation, query tuning, replica-set operations, security, and recovery. Small-group design reviews compare schema and shard-key choices against stated workload requirements. On day five, participants consolidate their work into an implementation pack and application plan for a selected workplace database or service.

Course outline

Day 1: MongoDB foundations and document modelling

• MongoDB architecture: databases, collections, documents, BSON, and deployment components
• mongosh navigation, database creation, collection management, and script execution
• CRUD operations with insertOne, updateMany, replaceOne, deleteMany, and projections
• Document modelling with embedding versus referencing decisions
• One-to-one, one-to-many, and many-to-many relationship patterns
• Document growth, array design, and the 16 MB document limit
• MongoDB Compass document inspection, import, export, and visual schema analysis

Workshop: Model and build the initial collections for an order-management service, producing a documented embedding-and-referencing rationale.

Day 2: Querying, aggregation, validation, and indexing

• Query operators for comparison, logical conditions, arrays, embedded documents, and regular expressions
• Array updates with positional operators, arrayFilters, $push, $pull, and $addToSet
• Aggregation pipeline design using $match, $project, $group, $sort, and $set
• Multi-collection analysis with $lookup, $unwind, and pipeline joins
• JSON Schema validation, validation levels, and validation actions
• Index types: single-field, compound, multikey, text, partial, sparse, and TTL
• Index selection using query shape, cardinality, sort order, and the ESR guideline

Workshop: Build reporting pipelines and validation rules for order data, then produce an index plan for six stated application queries.

Day 3: Performance, consistency, and transactions

• Query execution stages, winning plans, rejected plans, and explain() verbosity modes
• Reading keysExamined, docsExamined, nReturned, executionTimeMillis, and collection scans
• Covered queries, index intersection, index prefixes, and sort optimisation
• MongoDB Compass performance tools and query-history investigation
• Read concern, write concern, read preference, and causal consistency
• Single-document atomicity and multi-document transaction boundaries
• Profiling slow operations and using operational metrics to prioritise tuning

Workshop: Investigate a deliberately degraded workload, capture explain() evidence, and deliver a before-and-after query-tuning report.

Day 4: Availability, scale, backup, and security

• Replica set members, elections, oplog replication, and failover behaviour
• Replica-set deployment patterns for development, staging, and production workloads
• Sharding concepts: shards, config servers, mongos, chunks, and balancer activity
• Shard-key selection using cardinality, write distribution, query routing, and growth forecasts
• MongoDB Atlas cluster configuration, scaling options, alerts, and performance advisor
• Backup methods, point-in-time recovery concepts, restore verification, and recovery objectives
• Authentication, role-based access control, network access rules, TLS, and auditing considerations

Workshop: Configure a resilient target architecture for the case study and produce a topology diagram with backup, restore, and access-control decisions.

Day 5: Production operations and implementation planning

• Operational health indicators: connections, replication lag, cache pressure, locks, and disk capacity
• Monitoring dashboards, alert thresholds, escalation paths, and incident triage
• Common operational failures: primary loss, replication lag, runaway queries, and storage exhaustion
• Backup restore drills and data-integrity verification steps
• Release management for indexes, validation rules, schema changes, and application compatibility
• Capacity planning using workload baselines, growth assumptions, and scaling triggers
• MongoDB operational runbooks, ownership models, and implementation governance

Workshop: Complete and present a MongoDB implementation pack containing schema, indexes, topology, recovery procedure, monitoring thresholds, and an operational runbook.

Tools & standards covered

MongoDB Community Server, MongoDB Compass, MongoDB Atlas, mongosh

A typical training day

Live online deliveries follow the same structure in the East Africa Time zone, with shorter screen blocks and longer breaks.

What the fee includes

How you can take this course

Certification

Participants who complete the full five days receive the Skillset Development Certificate of Completion, stating the course title, course code, dates and delivery format — suitable for professional-development records and employer reimbursement.

Frequently asked questions