MongoDB Developer Training

Overview
Get ramped quickly on MongoDB with a comprehensive training program for developers. Our developer training program
comprises a graduated, modular curriculum in two main parts:

Foundation Training Advanced Training

An entry-level training course Seven instructor-led,
comprising a series of four small group, practical
instructor-led classroom days. workshops.

The entire program can be completed in 2 consecutive weeks, or the parts can be spread out over a longer time. Students
can also choose to complete only part of the program according to their learning objectives.

Who Should Attend?

All application developers who use MongoDB will benefit from this training program. Developers may enter the program at
one of the foundation training days or advanced training workshops according to their existing knowledge and skills.

Outcome
A developer completing the program will go from knowing little or nothing about MongoDB to having a complete set of
skills to build sophisticated, high-performance MongoDB applications. At every stage of the program they will learn a new
facet of MongoDB and how to apply their knowledge to real-world application development.

Course Logistics
● Public and private training options are available. See mongodb.com/training for the public course schedule.

● Public classes are only delivered remotely.

● Private classes can be delivered in person or remotely. For in-person classes, all students must attend the class in
person.

● A minimum of two consecutive days of delivery must be scheduled.

● Each class accommodates up to 12 students.

● To fully participate in a class, students should be equipped with a computer that has:

○ full access to the strigo.io training delivery platform via a supported web browser
○ for remote classes - the ability to join a Zoom meeting via the desktop client or web browser,
and a microphone and webcam to share their audio and video
November 2021
MongoDB Developer Training
Foundation Training: Overview
Our entry-level developer training course comprises a series of four classroom days. Each day introduces new concepts
and skills and gets students closer to developing high quality, scalable, production applications using MongoDB. Training
focuses on what’s most important for developer productivity and teaches concepts and skills in a developer-oriented way,
including hands-on exercises throughout the course where appropriate.

Students are provided with a copy of the training slides and comprehensive lecture notes.

MongoDB Optimizing Design Skills and

Production-Ready
Developer Storage and Advanced
Development
Fundamentals Retrieval Features

Foundation training can be delivered in sessions of between 2 and 4 consecutive days. Each training day builds on
knowledge and skills acquired from the preceding prerequisite days. Students may choose to schedule all four days in a
row, or space them out according to their schedule or project timeline.

Each day includes a short, end-of-day student assessment with real-time results provided to students.

November 2021
MongoDB Developer Training
MongoDB Developer Optimizing Storage Design Skills and Production-Ready
Fundamentals and Retrieval Advanced Features Development
(DF100) (DF200) (DF300) (DF400)

Audience Developers and

Developers Developers Developers
Technical Managers

Duration 1 day 1 day 1 day 1 day

Prereqs None DF100 DF100, DF200 DF100, DF200, DF300

Topics ● What is MongoDB? ● Indexing ● Advanced Features ● Replication

● How to access ● Profiling ● Application ● Sharding
MongoDB ● Aggregation Development ● Security
● Storage and Retrieval ● Schema Design

Summary This training day covers This training day covers This training day covers a This training day covers a
in detail what MongoDB the fundamentals of broad set of MongoDB set of topics which make
is, its strengths and indexing in theory and in functionality beyond the difference between
where you should use it, practice, how to profile simple storage and an application being fit for
how to get up and database operations to retrieval, best practices production or not. What
running, and the breadth identify bottlenecks, the for application does a developer need to
of powerful functionality aggregation query development, and design do to ensure their
for storing and retrieving language and how to of application code and application is secure, to
data. move beyond simple database schema — the ensure it is highly
retrieval of raw data to most important part of a available and protects
in-database computation. well-written MongoDB data, and to ensure it will
application. scale when required in
future?

Outcome On completion of this On completion of this On completion of this On completion of this

training day you will have training day you will know training day you will have training day you will be
an understanding of what how to avoid common all the skills needed to able to evaluate and
MongoDB is and how it MongoDB mistakes build a complete, make vital deployment
can be a good fit for your (failing to correctly index performant, scalable decisions required when
development project. queries or leverage application. You will building business-critical,
This is an ideal training to database capabilities for understand what highly available and
take prior to the computation of data) and database functionality to secure applications. Lack
evaluation of MongoDB design your data access use and when to use it. of developer awareness
for use in your project, in for optimal performance. You will be aware of the in these areas frequently
order to validate your This training is a must for paramount importance of leads to severe
planned development any developer writing good schema design and production deployment
effort. code which needs to know several common gaps cited by MongoDB
perform quickly and design patterns you can consultants, resulting in
efficiently. use in your applications. last-minute rework before
go-live. Using this
knowledge gets you
ahead of the game.

November 2021
MongoDB Developer Training
Foundation Training: Agenda

DF100: MongoDB Developer Fundamentals DF200: Optimizing Storage and Retrieval

Introduction Indexes and Optimization

● Why a new database? ● What are indexes?
● What are documents? ● MongoDB misconceptions
● MongoDB ● Single field indexes
○ Agility ● Reading explain plans *
○ Usability ● Indexes and performance
○ Utility ○ Limits
○ Scalability ○ Best practices
● When to use MongoDB ○ Compression
● Common mistakes ● Multikey indexes
● Compound index design *
Accessing MongoDB ● Covered queries
● Starting a cluster * ● Geospatial indexing *
● Installing a shell * ○ 2d indexes
● Using the web shell ○ Spherical indexes
● Connecting to your cluster * ● TTL indexes
● Text indexes
Developer Basics ● Wildcard indexing
● Container types ● How indexes are chosen
● Comparison with RDBMS ○ Query planner / Query optimizer
● Coding against MongoDB ○ Hints and tips
● Developer sandbox *
Database Profiling
● CRUD examples *
● Finding slow operations
Storage and Retrieval ○ Slow query log
● Bulk versus single writes ○ Enabling the profiler
● Filtering and projection ● Causes of slow operations
● Basic query operators *
Using Aggregation
● Querying arrays
● Expressive queries ● Aggregation basics
● Using cursors ● How to code aggregation
● Basic update operations * ● Using the GUI pipeline builder
● Array update operations * ● Stages and expressions *
● Expressive updates ○ Grouping *
● Advanced atomicity models ○ Joining / Classifying / Reshaping
○ Upsert ● Database internal statistics
○ findOneAndUpdate ● Expression variables
● Optimizing aggregation *
End of day test
End of day test

November 2021

* includes hands-on exercise

MongoDB Developer Training
Foundation Training: Agenda (continued)

DF300: Design Skills and Advanced Features DF400: Production-Ready Development

Functionality Beyond Storage Replication

● Regular expressions ● Reasons to replicate data
● Schema validation ● Components of a replica set
● GridFS ● Drivers and replica sets
● Change streams ● The concept of majority
● Sessions ● Elections simplified
● Retries ● Failure modes *
● Transactions ● Write Concern *
● Bulk write models ● The Majority Commit Point
● Server-side JavaScript ● Read Concern
● Atlas Search / Atlas Triggers ● Read Preference
● Views
Sharding
Internals Developers Should Know
● What is sharding?
● BSON data types ● Horizontal versus vertical scaling
● Null handling ● When to shard
● Collation and ordering ● Sharding infrastructure
● Type bracketing ● Shard keys *
● Sorting container types ● How sharding works
● Internal locking models ○ Reads / Writes / Chunks
● Long-term lock management ● Sharding in slow motion
● Sharding pitfalls
Developer Best Practices ○ A cautionary tale
● Coding for idempotency ● Managed sharding technique
● Understanding the drivers * ○ Computed keys
● Error handling ○ Presplitting
● Majority writes ○ Scaling out
● Authentication pools
Security
● Codecs, DALs and ODMs
● Driver helpers ● Introduction to keys and PKI *
● Authentication models
Schema Design ● Authorization
● BSON internals * ○ Roles
● Choosing container types * ○ LDAP
● Design fundamentals ● Encryption
● Linking models ○ In flight
● Payload versus process ○ At rest
● Dynamic schema ○ In use
● Design patterns * ● Auditing
● Additional security measures
End of day test
End of day test
November 2021

* includes hands-on exercise

MongoDB Developer Training
Advanced Training: Overview
Classroom training, even with exercises, is no substitute for deep practical experimentation and observation. MongoDB
advanced training workshops enable a much more in-depth exploration of a topic through a series of technical challenges.

In these workshops students typically investigate and demonstrate the impact made by a change to design or the use of a
feature. Students work together with each other and with the instructor – evolving code, answering questions and
discussing the observed behaviors.

Students can choose any subset of workshops according to the areas in which they would like to deepen their skills.
Workshops can be taken in any order, although the order shown below is recommended.

Advanced training workshops are technically demanding and as a prerequisite require students to have successfully
completed all four days of foundation training. Workshops are limited to 12 students per class.

Atlas Search
1 day

Atlas Data Lake

1 day

Advanced Queries and Data Processing

1 day

Languages, Drivers, Web Services

1 day

Distributed Systems and Transactions

1 day

MongoDB Application Optimization

1 day

Code Evolution, Scale and Workflow

2 days
November 2021
MongoDB Developer Training
Advanced Training:

Atlas Search (DS110)

Overview
MongoDB Atlas Search makes it easy for developers to build fast, relevant, full-text search on top of data in MongoDB
Atlas. In this specialty training course, students are introduced to Atlas Search and learn everything they need to know to
implement and optimize relevance-based search functionality for applications built with MongoDB Atlas.

Intended Audience
This training is intended for developers who have completed DF100 (MongoDB Developer Fundamentals) and can perform
basic MongoDB queries already, as well as architects looking to assess the capabilities of Atlas Search. This course is
taught using both the Atlas GUI and the MongoDB shell to demonstrate the required API calls.

Course Objectives
In this specialty course, you will learn how to:

● Identify appropriate use cases for Atlas Search

● Design and implement Atlas Search indexes

● Query Atlas Search and tune your queries to adjust result ranking

● Augment search results with scores and highlighting

● Implement synonym tables for context-sensitive matching

● Determine what instance size is required for your search capabilities

Duration
1 day

November 2021
MongoDB Developer Training
Advanced Training:

Atlas Data Lake (DS120)

Overview
MongoDB Atlas Data Lake allows developers to natively query and combine data across MongoDB Atlas databases and
AWS S3 without complex integrations. In this specialty training course, students will learn everything they need to know to
successfully implement Atlas Data Lake and to begin working with their data.

Intended Audience
This training is intended for developers who have a solid grounding in the MongoDB Query API attained through
completion of DF100 (MongoDB Developer Fundamentals) and DF200 (Optimizing Storage and Retrieval), have basic
familiarity with MongoDB Atlas, and are looking for an easy way to query, transform and seamlessly combine data across
AWS S3 and MongoDB Atlas databases.

Course Objectives
In this specialty course, you will learn how to use Atlas Data Lake successfully by:

● Learning what Atlas Data Lake is and what problems it addresses

● Deploying an Atlas Data Lake and populating it with data

● Querying and manipulating data in your data lake using the MongoDB Query API, including federated queries
across AWS S3 and Atlas databases

● Transferring data between Atlas databases and S3 using Atlas Data Lake specific aggregation operators

● Pre-processing data using scheduled triggers

● Using MongoDB Charts to visualize data in Atlas Data Lake

● Administering Atlas Data Lake using GUI and command-line interfaces

Duration
1 day

November 2021
MongoDB Developer Training Program
Advanced Training:

MongoDB Advanced Queries and Data Processing (DA610)

Overview
The MongoDB Query Language has many capabilities that untrained engineers are either unaware of or unsure how to
best use. This lack of knowledge can result in code that underperforms or has edge cases that impact correctness. The
aggregation framework enables writing functional expressions that run inside the database, close to the data, to perform
analysis, updates and computation. In this workshop, we move through a series of short but challenging exercises using
advanced MongoDB Query Language and aggregation features. Mastery of these skills allows one to achieve far more
with MongoDB than merely using it as a data store.

Intended Audience
This training workshop is intended for developers who have completed DF200 (Optimizing Storage and Retrieval) or who
are already comfortable with using the most common MongoDB aggregation operators such as $project, $group and
$unwind, and who want to be able to push significant computation and data manipulation closer to their data.

Workshop Objectives
In this training workshop, you will learn how to:

● build nested queries

● create complex queries using expressive syntax

● adopt best practices for when to project, enrich or redact your data to optimize your queries

● choose between various options for bucketing and summarizing your data

● optimize cross-collection data aggregation

● create non-blocking and highly parallel aggregation operations

● use list comprehension to implement complex functions

● optimize database computation using $let

Duration
1 day

November 2021
MongoDB Developer Training
Advanced Training:

Languages, Drivers, Web Services (DA620)

Overview
In this training workshop we create a scalable, stateless web service to perform a real-world business task. Using three
different styles of programming language (dynamic, static, and asynchronous), we compare the performance, readability
and functionality of these three language styles as well as provide a reusable foundation to create new services. We
measure performance and observe which factors influence it. We then look at what bottlenecks exist in our solution and
design ways to overcome any limitations before finally learning a new design pattern as we create a consumer replenished
resource service.

Intended Audience
This training workshop is intended for developers who have completed DF300 (Design Skills and Advanced Features) and
who intend to build a multi-user, shared-data application and want to understand how to do so in a way that will scale well
and make optimal use of database resources. This is a polyglot programming course but taught in a way that means
knowledge of any modern programming language will equip you to complete it.

Workshop Objectives
In this training workshop, you will learn how to:

● implement isolation using advanced MongoDB update operators

● evaluate the implied infrastructure costs of different app language choices

● understand the impact of network latency between application servers and the database

● diagnose hidden resource contention and eliminate unnecessary performance loss

● implement mechanisms to reduce database resource contention for better throughput

● ensure traceable message delivery to clients

Duration
1 day

November 2021
MongoDB Developer Training
Advanced Training:

Distributed Systems and Transactions (DA630)

Overview
Nearly all MongoDB production systems are highly available and distributed; even if distribution is only over a small
distance, data is held in multiple independent places. Students will have learned in foundation training the decisions
required to define “durable” and “safe” in a distributed system and how these responsibilities partly fall to the developer to
implement correctly. In this workshop we experiment with settings that affect speed, latency, durability and business
correctness to learn how and when to use concerns and transactions in MongoDB.

Intended Audience
This training workshop is intended for developers who have completed DF400 (Production-Ready Development) and want
to fully understand where a distributed document database necessitates important additional design decisions. This
workshop is for those who care about performance and correctness and how to achieve both.

Workshop Objectives
In this training workshop, you will learn how to:

● choose the appropriate write concern to ensure correctness of your application without unnecessarily sacrificing
performance

● safely and effectively use retryable writes

● understand the implications of selecting the wrong read concern and choose the appropriate read concern to
ensure correctness of your application without unnecessarily sacrificing performance

● decide when and when not to use transactions, taking into account contention and performance considerations

Duration
1 day

November 2021
MongoDB Developer Training
Advanced Training:

MongoDB Application Optimization (DA640)

Overview
In this training, students are presented with a working but unusable solution to a problem, in this case the storage and
retrieval of product review information. We work through an iterative process of application improvement to take a 20
second response time down to 20 milliseconds. We then learn how this can be further optimized by using lower-level APIs
in the MongoDB driver. This workshop helps students avoid lengthy refactoring in their next project — by understanding
how to do things correctly from the start.

Intended Audience
This training is intended for developers who have completed DF300 (Design Skills and Advanced Features) and need to
build an application that will work for many users and at significant scale. Optimizing your application to reduce your
infrastructure costs can easily make this the most valuable course you attend.

Workshop Objectives
In this training workshop, you will learn how to dramatically improve the performance of a MongoDB application by:

● leveraging indexes

● re-writing aggregation queries to ensure they use index covering

● implementing a caching pattern in the schema

● implementing a computed summary pattern in the schema

● using raw BSON data types to reduce the overhead of object creation

Duration
1 day

November 2021
MongoDB Developer Training
Advanced Training:

Code Evolution, Scale and Workflow (DA650)

Overview
In this training workshop, students create an application that evolves its schema over time to support new business needs
without needing to transform older data. This is a substantial benefit of dynamic schema in MongoDB, but one developers
often fail to take full advantage of. We build a social media service akin to Twitter and Facebook with followers, posts and
data feeds. We learn how to model high cardinality graphs and handle changes to tricky fields such as username, various
write models for extreme scale, and how to build asynchronous worker tasks to ensure the completion of long-running
operations even in the event of application or database failover.

Intended Audience
This training workshop is intended for developers who have completed DF400 (Production-Ready Development) and who
are embarking on a project to build a long-lived, highly-scalable application from the ground up. It will get you off to the
best possible start to ensure maximum performance and uptime over the lifetime of the application.

Workshop Objectives
In this training workshop, you will learn how to:

● create an adaptable data access layer (DAL) to decouple your objects from your schema

● use schema versioning to avoid having to rewrite older records

● use schema versioning to support running new and old application versions simultaneously

● identify bottlenecks which limit scaling and design schemas capable of managing millions of users

● apply caching design patterns to optimize retrieval time

● use collection-queues and background workers to complete long running tasks asynchronously

Duration
2 days

November 2021