C100DEV Data Modeling — Timed 30 Questions

Question 1

Which THREE factors should be considered when choosing between Embedding and Referencing in MongoDB?

Accepted Answer

The frequency and patterns of data access by the application.. Data modeling in MongoDB requires balancing document size limits, query patterns, and update frequency. Embedding favors read performance for related data, while Referencing supports data growth and structural flexibility. These three factors—access patterns, document growth, and data relationships—are the primary drivers of performance and scalability in MongoDB, directly influencing how the database engine handles memory, disk I/O, and concurrent write operations.

Answer

The total number of collections currently in the database.

Answer

The color-coding of the application code documentation.

Question 2

Which of the following describes the 'Extended Reference' pattern in MongoDB?

Accepted Answer

Storing only the most essential, rarely-changing data from a referenced doc.. The Extended Reference pattern involves embedding frequently accessed, read-only data from a referenced document into the primary document. This allows the application to avoid a join operation for common read requests while still maintaining the primary data source in a separate collection. It is a powerful optimization technique that balances the benefits of denormalization (speed) with the requirements of normalization (integrity and data management).

Answer

Embedding all data from a related collection to ensure maximum speed.

Answer

Referencing a document by its ID and performing a $lookup for all queries.

Answer

Adding a secondary index on all fields to speed up queries.

Question 3

When should you NOT use the Embedding pattern? Select TWO.

Accepted Answer

When the data being embedded grows indefinitely over time.. You should avoid embedding when data is unbounded, as this causes document bloat and violates the 16MB size limit, or when the data is frequently updated in a way that causes excessive document growth/relocation. Additionally, if the data is shared across many documents (many-to-many), embedding creates update anomalies and data duplication that are difficult to manage. Choosing correctly between these strategies is key to maintaining a performant and stable MongoDB cluster.

Answer

When the data is only used by one specific parent document.

Answer

When you need to keep the total document size small.

Answer

When you need to use an aggregation pipeline for analysis.

Question 4

Which pattern is best suited for storing data that changes rarely but is needed in many different queries?

Accepted Answer

The Extended Reference Pattern.. The Extended Reference pattern is ideal for data that is infrequently updated but frequently accessed alongside other information. By embedding a copy of this data into the primary document, you avoid repetitive lookups. This pattern is particularly useful for information like user settings or configuration flags, where the trade-off of maintaining a small amount of redundant data is far outweighed by the performance gain of eliminating joins.

Answer

The Bucket Pattern.

Answer

The Attribute Pattern.

Answer

The Polymorphic Pattern.

Question 5

Which TWO of the following scenarios are best suited for the Embedding pattern rather than Referencing?

Accepted Answer

A product document containing a small, fixed number of categories.. Embedding is preferred when data is accessed together as a unit and the relationship is 'contains' rather than 'linked'. By nesting data, you eliminate the need for application-level joins or $lookup stages, which significantly improves read performance. Choosing between embedding and referencing requires balancing read speed against the potential for unbounded document growth, making these two scenarios the classic use cases for embedding.

Answer

A user profile that needs to link to millions of social media posts.

Answer

A user document that needs to store an unbounded history of login timestamps.

Answer

A catalog where items frequently change and are shared across many vendors.

Question 6

Which THREE factors should you evaluate when deciding whether to embed or reference data?

Accepted Answer

The expected growth of the embedded data over time.. Deciding between embedding and referencing is the core of MongoDB schema design. You must consider the cardinality of the relationship, the access patterns of your application, and the physical constraints of the BSON format. These factors determine whether your schema will be performant and maintainable, as they dictate how the database engine handles I/O, concurrency, and document limits, ultimately impacting the entire application's responsiveness and stability.

Answer

The specific version of the MongoDB server in use.

Answer

The color scheme of the application interface.

Question 7

Refer to the exhibit. You have a document structure where orders are embedded in the user profile. As the number of orders grows, you notice performance issues during document updates. What is the most effective way to resolve this while maintaining read performance?

Accepted Answer

Move orders to a separate collection and use the Extended Reference pattern.. The issue is document growth, which causes MongoDB to relocate documents on disk, leading to heavy I/O overhead. Moving orders to a separate collection is the correct architectural pivot. By utilizing the 'Extended Reference' pattern, you can store the most critical order data (like the total) in the user document while keeping the bulk of the data elsewhere, providing a balanced solution that maintains read speed while optimizing update operations.

Answer

Increase the collection's padding factor to allow for document growth.

Answer

Implement a sharded cluster to distribute the user documents across nodes.

Answer

Use the $push operator with $each to batch all updates together.

Question 8

A financial analytics team stores daily trade records in MongoDB. Each document represents one trading day and contains a `trades` array of subdocuments with fields `symbol`, `price`, and `volume`. Queries typically filter by `symbol` and a date range, and the team needs to index efficiently. Which schema design consideration is most appropriate for this workload?

Accepted Answer

Store each trade as a separate document in a `trades` collection and rely on a compound index on `symbol` and `tradeDate`.. Separating trades into individual documents with a compound index on symbol and tradeDate supports efficient range queries and avoids unbounded array growth. This design keeps documents small, leverages MongoDB's indexing capabilities, and aligns with the principle of modeling for the most common access patterns without risking the 16MB limit.

Answer

Keep the daily array but add a multikey index on `trades.symbol` and a separate index on `trades.price`.

Answer

Embed all trades for the entire year in a single document and create a single index on the `trades` array.

Answer

Normalize trades into a separate collection and use `$lookup` to join them at query time without any indexes.

Question 9

A financial application stores transactions. Each transaction document includes fields: account_id, amount, timestamp, and a nested object 'metadata' that contains varying fields depending on the transaction type (e.g., 'check_number' for checks, 'card_last4' for card payments). Queries frequently filter on account_id and timestamp, and also need to search within metadata fields. The team wants to optimize read performance and minimize index size. Which schema design approach is most appropriate?

Accepted Answer

Use the Attribute Pattern by moving metadata fields into an array of key-value pairs, and create indexes on the key and value fields.. The Attribute Pattern is designed for documents with many similar fields that are queried in various combinations. By converting metadata into an array of key-value pairs, you can create a single compound index on the key and value fields, which supports queries on any metadata field efficiently. This reduces index size and improves performance for the described query patterns.

Answer

Use the Bucket Pattern by grouping transactions into buckets based on account_id and time range.

Answer

Use the Polymorphic Pattern by storing all transaction types in a single collection with a 'type' field and a flexible metadata subdocument.

Answer

Use the Extended Reference Pattern by embedding frequently accessed account information into each transaction document.

Question 10

A financial analytics application stores daily stock prices. Each document represents a single stock and contains an array of daily price entries. The array grows by one entry per trading day, and the application frequently queries the last 30 days of prices for a given stock. The number of tracked stocks is large, and the total data volume is expected to grow significantly. Which TWO schema design patterns are most appropriate to optimize this workload? (Choose two.)

Accepted Answer

Bucket Pattern: group daily prices into fixed-size buckets (e.g., 30 days per document) to reduce the number of documents and improve query performance for recent data.. The Bucket Pattern groups time-series data into fixed-size documents, reducing the number of documents and improving query performance for recent data. The Subset Pattern keeps only the most recent 30 days in the main document, ensuring fast access to frequently queried data while archiving older entries. Together, they address both the unbounded growth and the need for efficient retrieval of recent prices.

Answer

Polymorphic Pattern: store different types of financial instruments (stocks, bonds, options) in the same collection with varying fields to simplify application logic.

Answer

Computed Pattern: precompute and store the 30-day moving average and other aggregates in each stock document to avoid runtime calculations.

Answer

Extended Reference Pattern: embed frequently accessed fields from related collections into the stock document to avoid joins.

Question 11

An IoT platform stores sensor readings as one document per device per hour, with an embedded array of readings. Each document also stores a precomputed 'readingCount' and 'firstReading' timestamp. The application frequently needs the latest reading for a device. Which design consideration best supports this access pattern?

Accepted Answer

Keep the array sorted so the newest reading is at a known position, and index the 'firstReading' field for efficient range scans.. Ordering readings inside the bucket and indexing the bucket's time boundary lets the application find the most recent bucket with an index and read the newest element directly. This preserves the Bucket pattern's low document count while satisfying the frequent latest-reading query efficiently.

Answer

Store each reading as its own document and rely on a compound index on device and timestamp.

Answer

Store readings in a map keyed by a random identifier so writes distribute evenly, and scan values to find the newest.

Answer

Use a separate 'latest' collection updated on every write, and query only that collection for the newest reading.

Question 12

A financial application stores account documents. Each account references a customer by customerId, and customer documents are updated frequently (address, contact details, KYC status). Account queries almost always need the customer's current legal name and KYC status alongside the account balance. Which referencing design best meets the read and consistency requirements?

Accepted Answer

Store customerId plus a denormalized copy of the customer's legal name and KYC status in the account, and update those copies when the customer changes.. The extended reference pattern copies only the fields the read path needs, keeping account reads join-free while preserving customerId as the link to the authoritative record. Because the copied fields change infrequently, update fan-out stays bounded and can be handled with a targeted multi-document update. Full embedding or $lookup on every read over-serves the requirement, and making account copies authoritative destroys a single source of truth.

Answer

Keep only customerId in the account and resolve the customer with a $lookup on every account read.

Answer

Embed the customer document in the account and stop updating the customer collection, treating the account copy as the source of truth.

Answer

Embed the entire customer document inside each account document.

Question 13

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 14

Refer to the exhibit. You are implementing the Subset Pattern for a user profile that tracks recent orders. As the number of orders per user grows indefinitely, which strategy prevents the 'unbounded array' anti-pattern?

Accepted Answer

Keep only the 10 most recent orders in the array and offload older orders to a separate collection.. The Subset Pattern is designed to keep the most relevant data in the primary document while moving the bulk of historical data to a separate collection. By storing only the most recent orders in the array, you prevent the document from exceeding the 16MB limit and ensure that high-frequency read operations remain performant, as smaller documents yield better cache utilization in the WiredTiger engine.

Answer

Move all orders to a separate collection and reference them by ID in the user document.

Answer

Increase the maximum document size limit to accommodate the growing order array.

Answer

Use a capped collection for the orders array to automatically drop old orders.

Question 15

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 16

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 17

You are designing a schema for a social media platform. A user has a 'profile' document, and they can have thousands of 'followers'. How should you model the follower relationship?

Accepted Answer

Create a separate collection for followers and store references.. Storing thousands of followers in an array within the user profile document is a violation of the unbounded array anti-pattern, as it would cause the document to grow beyond the 16MB limit and result in poor write performance. Referencing the followers in a separate collection, where each follower is a separate document, provides a scalable solution that supports high growth and efficient querying without performance degradation.

Answer

Embed all follower IDs in an array within the user profile document.

Answer

Use the Attribute Pattern to store each follower as a key-value pair.

Answer

Store the followers in a gridFS file to handle the large size.

Question 18

When designing a schema for a time-series dataset, why is it recommended to use the 'Bucket' pattern?

Accepted Answer

It reduces index size and improves read performance by grouping data.. The Bucket pattern groups multiple related documents (like sensor readings) into a single document representing a time window (e.g., one hour). This significantly reduces the total number of documents in the collection, which improves index efficiency and reduces the memory footprint. By minimizing the index size, the database can keep more of the index in RAM, leading to faster query performance for analytical or time-based data retrieval.

Answer

It allows for unlimited document growth without checking the 16MB limit.

Answer

It automatically converts all data to a binary format for faster storage.

Answer

It enables ACID transactions for non-related collections automatically.

Question 19

Refer to the exhibit. The document uses the Attribute Pattern. Why is this model superior for indexing compared to storing specs as a single sub-document `{ RAM: '16GB', CPU: 'i7' }`?

Accepted Answer

It allows one index to cover any attribute query.. By using the Attribute Pattern with an array of key-value pairs, you can create a single multikey index on the 'specs.k' and 'specs.v' fields. This allows you to query any arbitrary attribute efficiently without having to create a separate index for every possible product specification. This approach provides a flexible, performant way to handle highly variable product schemas that would otherwise require hundreds of individual indexes.

Answer

It reduces the document size compared to sub-documents.

Answer

It enforces strict schema validation for every attribute.

Answer

It automatically performs joins between different products.

Question 20

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.