C100DEV Exam Simulation — 100 Questions

Question 1

What happens if a document grows beyond the 16MB limit due to an 'Embedding' design choice?

Accepted Answer

The write operation will fail.. When a document exceeds 16MB, the MongoDB write operation fails, and the database returns an error. The BSON document size limit is a hard constraint in MongoDB. This scenario highlights why 'unbounded array' design patterns must be avoided. When designing schemas, developers must ensure that embedded data sets have a predictable upper bound, or they must switch to a referencing strategy to maintain the integrity of their data storage.

Answer

MongoDB automatically moves the overflow data to a new document.

Answer

The engine automatically compresses the document to fit.

Answer

The document is split into two, and the original ID is shared.

Question 2

What is the primary advantage of the Subset pattern in MongoDB data modeling?

Accepted Answer

It keeps the working set small to improve cache performance.. The Subset pattern allows you to store the most frequently accessed data in the main document while offloading the rest to another collection. This ensures that the primary document remains small and fits efficiently into the WiredTiger cache, which significantly boosts read performance for common queries. By reducing the overall document size, you also avoid the 16MB BSON limit while still keeping essential information easily accessible for the application's most frequent use cases.

Answer

It eliminates the need for indexes on the collection.

Answer

It automatically scales the database across sharded clusters.

Answer

It prevents data duplication across different collections.

Question 3

Which tool is primarily recommended for performing binary backups and restores of a MongoDB deployment?

Accepted Answer

mongodump. mongodump and mongorestore are standard utilities for creating and restoring binary backups of MongoDB databases. Unlike mongosh which is for interaction, or Compass for visualization, these tools operate directly on the BSON data representation. Understanding the correct backup utility is essential for disaster recovery and data migration, ensuring that the integrity of the data is maintained during the backup process across different MongoDB versions.

Answer

mongosh

Answer

Compass

Answer

mongostat

Question 4

When modeling with MongoDB, why should you avoid 'unbounded' growth in an array field?

Accepted Answer

Because it can lead to hitting the 16MB document limit.. Unbounded arrays are a dangerous anti-pattern because every document has a hard 16MB size limit. As an array grows, the document size increases, eventually causing write operations to fail. Furthermore, updating large documents forces the database to relocate the entire object on disk, which creates significant performance overhead. By limiting array growth, you ensure the database remains stable, performant, and within the physical constraints of the BSON format for all future operations.

Answer

Because it makes the JSON syntax harder to read.

Answer

Because it prevents the use of secondary indexes.

Answer

Because MongoDB does not support arrays as a data type.

Question 5

Which of the following describes the behavior of a 'causally consistent' session in MongoDB?

Accepted Answer

It ensures operations are observed in their logical order.. Causal consistency ensures that operations within a session reflect the order in which they were performed. If an application writes a document and then immediately reads it back within the same session, causal consistency guarantees that the read will see the result of that write, even if the read is directed to a secondary node. This is vital for applications requiring linear-like history for user interactions across distributed read/write nodes.

Answer

It forces all reads and writes to the primary node.

Answer

It eliminates the need for replication in the cluster.

Answer

It significantly increases the latency of every write.

Question 6

When designing a schema for a one-to-many relationship, what is the primary factor in deciding between embedding and referencing?

Accepted Answer

The access pattern and the size of the related data.. The primary factor is the access pattern: how often the data is read and whether the related data is needed together. Embedding is ideal when the child data is frequently accessed with the parent. Referencing is necessary when the child data is large, grows unbounded, or is accessed independently. Choosing the right approach ensures that the application maintains optimal performance by minimizing read latency and avoiding document size limits.

Answer

The total number of documents in the collection.

Answer

The specific version of MongoDB being used by the server.

Answer

The hardware specifications of the database server.

Question 7

An e-commerce application stores products with fluctuating attributes. Which data modeling pattern is most effective for handling diverse product schemas while maintaining efficient filtering?

Accepted Answer

Implementing the Attribute Pattern with an array of key-value pairs.. The Attribute Pattern is the standard solution for schemas with heterogeneous fields. By transforming fields into an array of key-value pairs (k: 'color', v: 'red'), you create a uniform structure that allows for single-index coverage across all attributes. This avoids the limitations of sparse indexes and allows the application to query arbitrary attributes without needing to modify the document structure or rebuild large index sets frequently.

Answer

Embedding every possible attribute as a top-level field in the document.

Answer

Storing all product attributes as a single large JSON blob string.

Answer

Creating a separate collection for every individual product category.

Question 8

You are designing a schema for a social media platform where users have an array of 'tags' and an array of 'mentions'. You attempt to create an index on { tags: 1, mentions: 1 }. What is the most likely outcome of this operation?

Accepted Answer

The index build fails with an error stating that a compound index cannot include more than one array.. MongoDB restricts multikey indexes such that a single compound index cannot cover more than one array field. This limitation prevents the index from growing exponentially in size, which would happen if it had to create a cartesian product of every element in both arrays. Developers must choose which array is more critical for query performance or use alternative indexing strategies.

Answer

The index is created successfully and supports queries that filter by both tags and mentions.

Answer

The index is created but only the first element of each array is indexed to save space.

Answer

The index is created but it will only be used if the query provides a specific index hint.

Question 9

Refer to the exhibit. What is the most appropriate next step for an application encountering this error?

Accepted Answer

Abort the transaction and retry the entire operation.. The 'TransientTransactionError' label indicates that the failure occurred due to a temporary issue, such as a network hiccup or a transient server conflict. In accordance with MongoDB best practices, the application must catch this error, perform a rollback if necessary, and then retry the entire transaction from the beginning. This mechanism ensures that the application state remains consistent despite the intermittent nature of the underlying failure.

Answer

Display an error message to the user and stop.

Answer

Retry the individual failed operation only.

Answer

Ignore the error and continue with the next request.

Question 10

You are designing a schema for an e-commerce platform where products have a variable number of attributes like color, size, and material. Which modeling approach provides the best balance of flexibility and query performance for filtering products by these dynamic attributes?

Accepted Answer

Use the Attribute Pattern with an array of key-value subdocuments.. Using the Attribute Pattern is the standard MongoDB practice for handling heterogeneous data fields. By restructuring attributes into an array of subdocuments containing 'k' (key) and 'v' (value) fields, you can create a single multikey index on this array. This allows the database to efficiently query across arbitrary product properties without requiring schema changes or thousands of unique collection indexes as requirements evolve over time.

Answer

Create a separate collection for every unique attribute type.

Answer

Store all attributes as top-level fields in the document.

Answer

Serialize all product attributes into a single binary Large Object field.

Question 11

Which TWO of the following scenarios are best suited for using the 'Subset Pattern' in MongoDB?

Accepted Answer

A blog post collection where you display the last 5 comments on the main view.. The Subset Pattern is used to prevent documents from growing too large while keeping frequently accessed data local. By embedding only the most important subset of child documents (e.g., the five most recent comments) and referencing the rest, you balance read performance with document size management. This is essential for maintaining consistent performance levels as datasets scale, ensuring that the working set remains efficient for typical user queries.

Answer

A shopping cart collection where items are added and removed constantly.

Answer

A product catalog where you need to filter by over 100 different categories.

Answer

An audit log collection where every action must be stored for compliance.

Question 12

You are processing a large collection of user sessions. You need to calculate the average duration of sessions grouped by 'userId', but you must filter out any sessions lasting less than 5 seconds before performing the grouping. Which stage order is most efficient?

Accepted Answer

$match then $group. Filtering data as early as possible in an aggregation pipeline is a fundamental optimization technique. By placing the $match stage before the $group stage, you significantly reduce the number of documents that need to be processed by the subsequent grouping operation. This reduces memory usage and improves overall pipeline performance by limiting the dataset size early on, which is critical when working with large-scale production collections.

Answer

$group then $match

Answer

$project then $match then $group

Answer

$group then $project then $match

Question 13

What is the primary consequence of having too many indexes on a collection that experiences a high volume of write operations?

Accepted Answer

Decreased performance of write operations.. Every index on a collection must be updated whenever a document is inserted, updated, or deleted. In write-heavy workloads, this results in significant write amplification. Each write operation triggers multiple index update tasks, consuming CPU and I/O resources. Maintaining excessive indexes leads to performance degradation as the system struggles to keep all indexes synchronized with the base data, directly impacting latency and throughput for application-level database interactions.

Answer

Increased disk space usage for data storage.

Answer

Increased memory usage for query execution.

Answer

Improved speed for data deletion operations.

Question 14

Which of the following describes the 'Extended Reference' pattern and its primary use case?

Accepted Answer

Copying frequently accessed fields to a referenced document to minimize joins.. The Extended Reference pattern involves copying frequently accessed fields from a referenced document into the current document. This eliminates the need for costly $lookup operations during read queries. It is a vital pattern for high-performance applications where latency is critical, as it trades a small amount of data redundancy for significant gains in read speed by enabling single-document retrieval for complex data views.

Answer

Embedding all child documents to ensure total data atomicity.

Answer

Storing the entire child document inside the parent for faster retrieval.

Answer

Using an array of document IDs to link parent and child documents.

Question 15

Which of the following best describes the purpose of the MongoDB 'mongosh' shell?

Accepted Answer

To serve as a modern interactive JavaScript shell.. The 'mongosh' shell is the modern, interactive command-line interface for MongoDB. It allows developers to run JavaScript commands to interact with the database, perform CRUD operations, manage indexes, and execute administrative tasks. It replaces the legacy 'mongo' shell, offering improved features like syntax highlighting, auto-completion, and better integration with current MongoDB server versions, making it the essential tool for daily development and database management tasks.

Answer

To act as a GUI for database administration.

Answer

To perform background replication between nodes.

Answer

To automatically optimize database query indexes.

Question 16

An e-commerce application models product reviews inside an array on the product document. As popular products accumulate hundreds of thousands of reviews, write operations and document fetch operations experience performance degradation. Which data modeling pattern best resolves this issue?

Accepted Answer

Implement the Bucket Pattern by storing a limited number of reviews per document alongside grouping metadata, creating new bucket documents as needed.. Migrating from an unbounded embedded array to the Bucket Pattern divides reviews into manageable document chunks based on a count or time threshold. This prevents documents from exceeding the 16MB limit and reduces RAM pressure. Managing growth ensures predictable update performance and maintains indexing efficiency across high-throughput collections in production workloads.

Answer

Keep the array embedded but add a partial index to speed up searches on the most recent reviews inside the array.

Answer

Move every review into its own separate collection and establish a manual join reference back to the parent product ID.

Answer

Convert the reviews array into a capped collection and use tailing cursors to push updates directly to the product document.

Question 17

Refer to the exhibit. You have a collection where each document contains a 'tags' array. If you frequently query for documents containing specific tags, what is the best way to model and index this data?

Accepted Answer

Use the multikey index created on the tags array.. MongoDB automatically creates a multikey index when you index an array field. This allows the query engine to efficiently find documents that contain any of the elements in the array. This index type is highly performant for tag-based filtering because it maps every element in the array to the document location, enabling rapid searches without scanning every document in the collection.

Answer

Convert the tags array into a comma-separated string.

Answer

Create one index per tag value to ensure performance.

Answer

Store tags in a separate collection and reference them using an object ID.

Question 18

What is the primary benefit of the 'Bucket Pattern' in MongoDB data modeling?

Accepted Answer

It keeps document sizes within reasonable limits for time-series data.. The Bucket Pattern is used to avoid the 'unbounded array' problem, where a single document could grow indefinitely. By grouping data into manageable 'buckets' (e.g., one document per day of sensor data), the pattern keeps document sizes manageable, ensures efficient indexing, and optimizes write performance. This approach prevents documents from hitting the 16MB limit while maintaining query speed for time-series data.

Answer

It eliminates the need for any indexing on the collection.

Answer

It forces data normalization across multiple sharded clusters.

Answer

It automatically migrates old data to archival storage systems.

Question 19

Which TWO of the following scenarios are optimal for using the Embedding pattern instead of Referencing?

Accepted Answer

A user document containing the user's primary shipping address.. Embedding is preferred when data is accessed together or exhibits a 'contains' relationship, minimizing round trips. It is ideal for one-to-few relationships. Conversely, Referencing is better for large, unbounded datasets or many-to-many relationships. Understanding these trade-offs is critical for MongoDB developers to minimize I/O and maximize the efficiency of read operations, as embedded documents are retrieved in a single read operation by the database engine.

Answer

A blog post containing a list of comments that grows indefinitely.

Answer

A product catalog with millions of items linked to various categories.

Answer

A sensor data stream that stores millions of readings per hour.

Question 20

Which operator is used to calculate the average value of a numeric field in a $group stage?

Accepted Answer

$avg. The $avg accumulator operator is used to compute the mean of all numerical values for a specific field across a group of documents. It is a fundamental tool for data analysis and reporting. Knowing how to use accumulators within the $group stage is essential for generating meaningful insights from raw data, which is a primary use case for the MongoDB Aggregation Framework.

Answer

$mean

Answer

$sum

Answer

$median