C100DEV Data Modeling Practice Test 3 — 15 Questions

Question 1

When should you use the 'Computed Pattern' in MongoDB?

Accepted Answer

When the data is accessed frequently and requires an expensive calculation.. The Computed Pattern is used to store calculated values (like totals, counts, or averages) directly within a document to minimize expensive real-time calculations. This is vital when the cost of computing a result exceeds the cost of updating a stored value. It is particularly effective for read-intensive workloads where the computed result is requested frequently, allowing the application to simply read the pre-calculated value from the document.

Answer

When you have a high write-to-read ratio for the specific data field.

Answer

When you need to store binary large objects (BLOBs) in the database.

Answer

When you want to prevent all indexing on a specific collection.

Question 2

Which approach is best for handling a 'One-to-Squillions' relationship in MongoDB?

Accepted Answer

Store the parent ID in the child documents.. For a 'One-to-Squillions' relationship, where a parent has a massive, unbounded number of children, neither embedding nor an array of references is viable. Storing the parent ID in the child documents (the 'referencing' pattern) is the only scalable solution. This allows the child documents to be queried efficiently by the parent ID without hitting document size limits or requiring massive updates to the parent document during growth.

Answer

Embed all child documents inside the parent document.

Answer

Store an array of child IDs in the parent document.

Answer

Use a separate collection for each child to ensure isolation.

Question 3

What is the primary benefit of the 'Extended Reference Pattern'?

Accepted Answer

It improves read performance by reducing the need for joins.. The Extended Reference Pattern involves copying a small amount of frequently accessed data from a referenced document into the primary document. This allows the application to retrieve the most critical information in a single read, avoiding a join for the majority of use cases. It optimizes for the common case while still allowing the full referenced document to be fetched only when truly needed.

Answer

It completely eliminates the need for any referencing in the database.

Answer

It allows documents to grow indefinitely without size limits.

Answer

It ensures that all data across all collections remains perfectly synchronized.

Question 4

What is the primary risk of using the 'Linking Pattern' improperly?

Accepted Answer

It reduces read performance due to increased $lookup overhead.. The primary risk is creating too many 'joins' (lookups) in the application, which leads to slow performance. When you link data across collections, the database must perform extra work to resolve these references. If done too frequently, especially in high-traffic read paths, it creates significant latency and increases the load on the database, which directly undermines the performance benefits usually associated with MongoDB's document-based architecture.

Answer

It causes data inconsistency.

Answer

It forces the use of fixed schema documents.

Answer

It prevents the use of secondary indexes on the collection.

Question 5

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 6

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 7

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 8

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 9

You are designing a schema for a social application where each user document stores an array of their last 50 notifications. Notifications are frequently added, and the application only needs to display the most recent 50. Which schema design approach best supports this requirement while minimizing document growth?

Accepted Answer

Use the Subset Pattern by embedding only the most recent 50 notifications and storing older ones in a separate collection.. The Subset Pattern is the best fit because it keeps only the most frequently accessed data (the latest 50 notifications) embedded in the user document while offloading older notifications to another collection. This keeps the document small, avoids hitting the 16MB limit, and ensures fast access to recent notifications without unnecessary complexity.

Answer

Use the Bucket Pattern by grouping notifications into fixed-size buckets based on time.

Answer

Use the Extended Reference Pattern by embedding notification counts and frequently accessed fields from the notification documents.

Answer

Use the Computed Pattern by precalculating and storing the total number of notifications per user.

Question 10

A social media application stores user posts. Each post document currently embeds a comments array. A single popular post can accumulate over 50,000 comments, causing the document to grow beyond 10 MB. The development team wants to avoid hitting the 16 MB document size limit while still being able to retrieve a post with its most recent 10 comments in a single query. Which schema design should they implement?

Accepted Answer

Keep the most recent 10 comments embedded in the post document and store older comments in a separate comments collection.. The Subset Pattern is ideal when a document contains a large array that grows indefinitely. By embedding only the most recent 10 comments, the post document remains small and the application can still fetch the post with its recent comments in one read. Older comments are stored separately, preserving access to historical data without bloating the main document.

Answer

Move all comments into a separate comments collection and store an array of comment _ids in the post document.

Answer

Use a capped collection for the posts collection to automatically limit document size.

Answer

Convert the comments array into a GridFS bucket and store the file reference in the post document.

Question 11

A social media platform stores user profiles in a `users` collection. Each user document includes a `followers` array of user IDs. For highly popular accounts, this array has grown to over 2 million entries, causing documents to approach the 16 MB BSON limit and slowing read operations. The application frequently displays a user's follower count and the first 20 followers. Which schema design change best addresses this issue?

Accepted Answer

Use the Outlier Pattern: store the first 1000 followers in the user document and flag the document as an outlier; store remaining followers in a separate `followers` collection keyed by user ID.. The Outlier Pattern is specifically designed to handle documents that grow beyond typical limits due to a few outliers. By embedding only a subset of followers and storing the rest separately, the design keeps the common case fast while accommodating the extreme case. This maintains the ability to quickly show the follower count and first 20 followers without hitting the 16 MB limit.

Answer

Convert the `followers` array to a GridFS bucket to store the list of follower IDs as a binary blob.

Answer

Normalize the schema by moving the entire `followers` array into a separate `followers` collection with one document per follower relationship.

Answer

Apply the Attribute Pattern by converting the `followers` array into a set of key-value pairs where each follower ID is a field name.

Question 12

A financial analytics team stores daily stock snapshots as one document per symbol per day in a collection named 'prices'. Each document contains an array of 60 subdocuments, one per minute, with fields 'minute', 'open', 'close', and 'volume'. The team now needs to compute the hourly average 'close' for a single symbol over a single day. Which aggregation approach is most appropriate for this schema?

Accepted Answer

Use $unwind on the minute array, then group by an expression that truncates 'minute' to the hour and average 'close'.. The data is stored in buckets, so per-minute analysis requires expanding the embedded array before grouping. $unwind emits one document per array element, and a subsequent $group can bucket by a truncated hour value and compute the average 'close'. This preserves the storage benefits of embedding while still enabling fine-grained aggregation over the measurements.

Answer

Run a $match for the symbol and day, then use $replaceRoot with the minute array to promote each element.

Answer

Use $group with $push to collect all 'close' values into an array, then apply $avg to the array.

Answer

Create a separate collection with one document per minute and migrate the data, then aggregate over it.

Question 13

A social media platform stores each user's followers as an array of ObjectIds inside the user document. Power users can have millions of followers, and the application frequently needs to paginate through the follower list and display total counts. Which data modeling change best addresses the document growth and query performance concerns?

Accepted Answer

Store followers in a separate collection with one document per follower relationship, indexed on the followed user.. When an embedded array can grow without a realistic upper bound, the document risks hitting the 16MB BSON limit and queries become costly because large arrays must be scanned. Modeling the relationship as its own collection with a supporting index keeps documents small, enables efficient pagination, and allows accurate counts using standard aggregation or count operations.

Answer

Convert the followers array into a GridFS bucket so that the follower list is chunked across multiple files.

Answer

Add a $slice projection to every query so only the first 100 followers are ever returned to the application.

Answer

Increase the document size limit by enabling the largeDocuments storage engine option on the replica set.

Question 14

A social platform stores user profiles in a 'users' collection and their posts in a 'posts' collection. Each post document embeds a small 'author' subdocument with 'userId', 'displayName', and 'avatarUrl'. A user changes their display name. The application must keep existing posts showing the new name. What is the most accurate statement about this Extended Reference design?

Accepted Answer

The change requires an update to the user document plus a multi-document update to every post embedding that author's duplicated fields.. Extended Reference embeds a small set of frequently accessed fields to avoid extra reads, accepting duplication as the cost. Because MongoDB does not synchronize fields across collections, any change to a duplicated field must be written to the source document and to every embedding document. The design is valid and useful, but the application owns consistency.

Answer

The design is invalid because embedding an author subdocument violates the rule that referenced data must never be duplicated.

Answer

The design guarantees strong consistency between the user document and all posts as long as both writes occur in a single transaction.

Answer

No propagation is needed because MongoDB automatically synchronizes duplicated fields across collections when the source document changes.

Question 15

A social media application stores user profiles with an embedded `friends` array containing friend IDs. The array can grow to thousands of entries. Queries frequently need to find mutual friends between two users. Which schema design strategy best optimizes this workload in MongoDB?

Accepted Answer

Model friendships as separate documents in a `friendships` collection with fields `user1` and `user2`, and create a compound index on both fields.. Modeling friendships as separate documents with a compound index on both user fields enables efficient indexed lookups for mutual friends. This design avoids the pitfalls of unbounded arrays and leverages MongoDB's indexing to handle large-scale social graphs, ensuring queries remain performant as the dataset grows.

Answer

Keep the embedded `friends` array and create a multikey index on it to support mutual friend queries.

Answer

Store the `friends` array as a GridFS bucket to bypass the 16MB document limit and query it with aggregation.

Answer

Use a `$lookup` aggregation to join the user's `friends` array with another user's `friends` array at query time.