MongoDB Associate Developer: Complete 2026 Study Guide

Exam facts and the non-official practice allocation

The MongoDB Associate Developer Certification validates developer reasoning rather than database administration trivia. The public exam page identifies a compact timed multiple-choice assessment: 53 questions in 75 minutes, delivered online with proctoring, and no prerequisites. Delivery rules, identity checks, prices, retakes, supported languages, and technical policies can change, so verify the live page before scheduling.

The official study guide requires enrollment before its detailed material is exposed publicly. It would be misleading to convert private or unknown weighting into a claimed blueprint. PrepKloud therefore uses a transparent INTERNAL NON-OFFICIAL 50-question practice allocation:

Those counts are study coverage, not MongoDB percentages. The technical boundaries come from official server, Atlas, and driver documentation.

Document model and schema design

MongoDB's flexible document model does not mean “do not design a schema.” It means schema can reflect application objects and evolve deliberately. Start with access patterns: what is read together, written together, independently updated, high-cardinality, bounded, latency-sensitive, and consistency-sensitive? The core guidance is to store together what the application accesses together, while respecting document growth and independent ownership.

Embedding fits bounded relationships owned by the parent. Product specifications, a shipping address snapshot, or a small current state can often live inside one document, providing locality and single-document atomicity. Referencing fits data with an independent lifecycle, unbounded growth, many-to-many relationships, or separate query patterns. An author with thousands of independently queried articles should not accumulate every article in one growing array.

Learn design patterns as tradeoffs rather than templates. The subset pattern embeds only the recent or most common subset while preserving full history elsewhere. The bucket pattern groups time-oriented or high-volume events into bounded documents. The computed pattern stores a derived value when reads greatly outnumber changes, but it needs update and reconciliation semantics. The polymorphic pattern allows variants in one collection while a discriminator and validation retain clarity.

Schema validation belongs at the database boundary for stable invariants. A JSON Schema validator can require a string identifier, constrain numbers, or express variant branches. It complements application validation; it does not replace threat modeling, authorization, migration, or compatibility planning. Test malformed data and decide validation action and level according to current documentation.

CRUD and query operators

MongoDB query filters are documents composed from field conditions and operators. Precision matters. A scalar equality on an array field can match an element, while equality to an array compares the complete array including order. Separate conditions on paths under an array can be satisfied by different elements; $elemMatch is required when the same element must satisfy all predicates.

Null requires deliberate handling. A filter for null can also match a missing field. If a requirement says “present and non-null,” combine existence and non-null logic. Projections normally choose inclusion or exclusion, with the familiar exception that an inclusion projection can exclude _id. Avoid returning fields the caller does not need, but do not call every projection a covered query; coverage depends on the index and query shape.

Use update operators instead of reconstructing whole documents when field updates express the intent. $inc is useful for atomic counters, $addToSet for set-like arrays, $push for append semantics, and filtered positional updates for matching embedded elements. Upsert inserts when no match exists; $setOnInsert applies only to that inserted case. Test equality fields from the upsert filter and avoid broad filters that can create unexpected documents.

Concurrency should be encoded in the write. findOneAndUpdate can atomically claim one queued job. A version field in the update filter implements optimistic concurrency: a zero matched count means another writer changed the document. Single-document writes remain atomic, so many invariants can be protected without a distributed transaction.

Indexes and query performance

An index stores ordered keys and record references so MongoDB can avoid scanning every document for suitable queries. The default unique _id index exists for every ordinary collection. Additional indexes are workload choices, not free accelerators: they consume storage, memory, build time, and write maintenance.

Design compound indexes from complete query shapes: equality predicates, sorting, range predicates, projections, and frequency. The equality-sort-range guideline is a useful starting point, but selectivity and actual plans matter. Index prefix behavior means a compound index can support certain leading-field shapes but not arbitrary suffix-only searches. Sort direction matters relative to equality-bound prefixes and supported reverse traversal.

Arrays make indexes multikey automatically. Understand restrictions when multiple indexed paths can be arrays. Unique indexes enforce key uniqueness but missing and null semantics require care. Partial indexes reduce index size by indexing only documents that meet a filter; queries need compatible conditions. TTL indexes expire data according to documented background processing and are not an exact scheduler.

Use explain evidence. A collection scan and a huge totalDocsExamined-to-nReturned ratio are clues, not a command to index every field. Compare winning plan, keys examined, documents examined, returned results, sort stages, and representative latency. Then rerun writes and storage measurements. An index that improves one read but materially harms the dominant write workload can be the wrong production choice.

Aggregation pipelines

A pipeline passes documents through ordered stages. Place selective $match stages early when semantics allow so later stages process fewer documents and a suitable initial predicate may use an index. Use $project to reshape, $unwind to deconstruct arrays, $group with accumulators to summarize, $sort and $limit to rank, and $count to name the resulting count.

$lookup joins another collection. Equality remains BSON-type-sensitive: an ObjectId does not equal its string representation. Align schemas and indexes rather than hiding inconsistent types behind pervasive conversion. Pipeline-form lookups add expressiveness but should be measured for index use and cardinality. $facet applies multiple sub-pipelines to one input and is useful for data plus count responses after common filtering.

Blocking stages can consume substantial memory. Reduce input, avoid unnecessary wide documents, support ordering with indexes where possible, and evaluate disk spilling against the deployed server version and operational limits. Ordinary aggregate pipelines do not modify their input collection. $merge and $out are exceptions that persist output; they require permissions, unique-key thought, rerun semantics, and failure testing.

Drivers, connections, and errors

Choose an official driver version compatible with the deployed MongoDB server and language runtime. Reuse a long-lived MongoClient in the normal application lifecycle. It manages topology discovery and connection pools; creating and closing one per request repeats expensive setup and defeats pooling. Bound pool size and waits from service objectives and downstream capacity.

Connection strings are secrets. Store them outside source control, percent-encode reserved credential characters, preserve TLS verification, and sanitize logs. Atlas SRV records simplify seed discovery but do not remove the need for DNS, TLS, authentication, authorization, and network-path correctness.

Classify errors. Duplicate key and schema-validation failures are deterministic conflicts with the input; blind retries do not repair them. Server-selection timeouts, certain network errors, retryable writes, and transaction labels have documented transient handling. Use bounded retries and backoff where eligible, make business requests idempotent, and never report success after an ambiguous outcome without resolving it according to driver semantics.

Transactions and data consistency

Single-document writes are atomic. Good document modeling often keeps an invariant within one document and avoids transaction overhead. Multi-document transactions exist for invariants that truly span documents, collections, databases, or shards, but they add latency, resource usage, lock interaction, retries, and operational limits.

Transactions belong to a client session. Every intended operation must receive that session. The convenient callback API can retry the callback for a TransientTransactionError and retry commit for UnknownTransactionCommitResult under documented conditions. The callback must be safe to execute again and should not perform an irreversible external side effect such as charging a card or sending an email without a separate idempotent design.

Read concern, write concern, and read preference are guarantees, not difficulty labels. For example, snapshot read concern with majority commit write concern can supply a synchronized snapshot of majority-committed data across shards. Weaker settings can be valid for other workloads. State the business requirement first, then select and test the guarantee.

Atlas security and operations

Atlas control-plane identities and database users are separate. Give applications dedicated database users with only needed roles. Restrict public network access to required sources or use supported private connectivity. Do not solve a connection problem by granting organization owner, readWriteAnyDatabase, disabling TLS, or opening the cluster to the entire internet.

Use monitoring as evidence: latency, connections, queues, storage, CPU, memory, replication, and alerts. Query Profiler and Performance Advisor can reveal slow query shapes and index suggestions, but recommendations require validation against complete workload and write cost. Keep diagnostic output free of real credentials and sensitive application payloads.

Replication supports availability, not historical recovery from every operator or application mistake. Configure backup retention supported by the Atlas tier and test restore to an isolated target. A backup that has never been restored is an assumption. Record recovery-point and recovery-time evidence and delete the restore after validation.

Version caveats

MongoDB is a family of moving parts: server release, feature compatibility version, Atlas tier and rollout, mongosh, official driver, language runtime, and application framework. A behavior documented for one release may be changed, deprecated, restricted, or unsupported elsewhere. Record every version in projects and answer questions from the referenced current docs, not from a screenshot.

The official documentation provides version selectors and release notes. Drivers have compatibility matrices. Transactions, retry labels, aggregation limits, index behavior, Atlas backup availability, and private networking details can be version- or tier-sensitive. The exam page and enrolled study guide remain the authority for current certification scope.

Three projects

The project set converts definitions into evidence. Project one designs a bounded commerce model, validates it, implements array queries and atomic updates, and proves transaction rollback. Project two creates representative query shapes, captures explain baselines, evaluates indexes, builds pipelines, and measures write/storage tradeoffs. Project three builds a secure Atlas-connected service with one client, bounded timeouts, classified errors, safe transaction retries, metrics, backup restoration, and complete credential revocation.

Eight-week plan

Question strategy

First identify the layer: schema, filter, update, index, pipeline, driver, transaction, or Atlas control. Second identify the exact invariant: same array element, non-null presence, atomic claim, sort support, cross-document all-or-nothing, or network versus database authorization. Third remove overclaims. “Always embed,” “index every field,” “retry every error,” and “transactions guarantee everything” are usually wrong because MongoDB behavior is workload- and guarantee-specific.

For code, trace BSON types and operation boundaries. ObjectId and String are not equal. A projection does not mutate. An ordinary pipeline does not persist. A transaction operation without the session is outside the transaction. A database role does not create network reachability. Explain each distractor by assigning it to the correct concept.

Official references

• MongoDB Associate Developer exam page
• Official exam study guide
• MongoDB data modeling
• MongoDB CRUD operations
• MongoDB indexes
• MongoDB aggregation
• Official MongoDB drivers
• MongoDB transactions
• Atlas security

Continue preparing

• MongoDB roadmap
• 50 original questions
• 40 flashcards
• Three projects
• Editorial policy

Frequently asked questions