C100DEV Data Modeling Practice Test 4 — 15 Questions

Question 1

A financial reporting system reads account documents that each contain a nested array of the last 90 daily balance snapshots. Analysts run aggregations that only need the current balance and account type, but the full snapshot array is being loaded on every read. Which schema pattern most directly reduces the working set size for these read-heavy analytics queries?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Subset Pattern, keeping only the most recent snapshots in the main document and archiving older ones in a separate collection.. The Subset Pattern is specifically designed for documents with a large array where only a small portion is accessed regularly. By retaining the frequently used snapshots in the main document and relocating the rest, the document shrinks, the working set fits more easily in RAM, and read-heavy analytics touch far less data while still returning the fields analysts require.

Answer

Schema Versioning Pattern, adding a version field so old documents can be migrated incrementally.

Answer

Computed Pattern, precomputing derived totals into new fields on the account document.

Answer

Bucket Pattern, grouping many accounts into a single document with shared metadata.

Question 2

A developer is designing a collection to store catalog items. Different item categories have different attributes: books have 'isbn' and 'pageCount', while electronics have 'wattage' and 'warrantyMonths'. All items share '_id', 'name', 'price', and 'category'. Which data modeling approach best fits this requirement?

Accepted Answer

Store all items in one collection and include only the attributes relevant to each item's category.. The Polymorphic pattern stores documents with a shared core plus category-specific fields in one collection. It supports queries across all items using common fields and queries within a category using the discriminator field. This is the natural fit when different document shapes share a meaningful set of fields and are queried together.

Answer

Create one collection per category, such as 'books' and 'electronics', and never query across them.

Answer

Normalize all attributes into a separate 'attributes' collection referenced by item documents.

Answer

Store all category-specific attributes in a single 'attributes' array of key-value pairs for every item.

Question 3

A library management system stores book information in a `books` collection. Each book document includes fields such as `title`, `author`, `ISBN`, and `genre`. The application frequently queries books by `genre` and `author`. Which index strategy is most appropriate to optimize these queries?

Accepted Answer

Create a compound index on `{ genre: 1, author: 1 }`.. A compound index on `{ genre: 1, author: 1 }` efficiently supports queries that filter on both fields or on `genre` alone, leveraging the index prefix. It also supports sorting by `genre` and `author`, which aligns with common library queries. Single-field indexes may require index intersection, which is less efficient, while text and hashed indexes are unsuitable for exact-match queries.

Answer

Create a text index on `title`, `author`, and `genre`.

Answer

Create a hashed index on `genre` and a regular index on `author`.

Answer

Create a single-field index on `genre` and another single-field index on `author`.

Question 4

A team is designing a schema for a product catalog where different product categories have entirely different attributes: books have ISBN and page count, electronics have wattage and warranty period, and clothing has size and material. All products must be searchable in a single query by name. Which data modeling approach best fits this requirement?

Accepted Answer

Store all products in one collection, allowing each document to have its own category-specific fields alongside common fields.. The Polymorphic Pattern is the standard MongoDB approach when multiple entity types share some fields and a common query path but differ in their specific attributes. Keeping all products in one collection with shared fields such as name and category-specific fields lets a single indexed query serve the catalog search while preserving each category's natural structure.

Answer

Create a separate collection per product category and query them with $unionWith for every search.

Answer

Normalize all attributes into a generic key-value array so every product has identical field names.

Answer

Embed every possible attribute for all categories in each document, leaving unused fields null.

Question 5

A team is designing a schema for a MongoDB application that stores user profiles. Each profile includes a list of the user's favorite movies, which is typically fewer than 20 items and updated infrequently. Queries often retrieve the entire profile along with the favorite movies. Which data modeling approach is most appropriate?

Accepted Answer

Embed the favorite movies as an array of subdocuments within the user profile document.. For a one-to-few relationship where the embedded data is small, updated infrequently, and always accessed with the parent document, embedding is the recommended approach. It simplifies queries, ensures atomicity, and provides the best read performance without the overhead of joins or multiple round trips.

Answer

Normalize the data by creating a separate collection for movies and a junction collection linking users and movies.

Answer

Use the Bucket Pattern to group favorite movies into buckets of 10.

Answer

Store favorite movies in a separate collection and reference them by _id in the user profile.

Question 6

A logistics company uses MongoDB to store shipment data. Each shipment document includes a status field that can be one of several values: 'pending', 'in_transit', 'delivered', 'cancelled'. The application frequently queries shipments by status and also needs to generate reports that count shipments per status. The team wants to ensure efficient queries and minimal index overhead. Which schema design consideration is most important?

Accepted Answer

Store the status as a string and create a single-field index on it.. For a field with a limited set of values that is frequently queried, a simple single-field index on that field is the most efficient and straightforward solution. It supports equality matches and aggregation for counting, and it has minimal impact on write performance. More complex patterns or compound indexes are not warranted based on the described access patterns.

Answer

Use a compound index on status and shipment_date to support both filtering and sorting.

Answer

Store the status as an integer code and create a single-field index on it.

Answer

Use the Attribute Pattern to store status as a key-value pair and index the key and value fields.

Question 7

An IoT platform ingests temperature readings from thousands of sensors. Each reading is currently stored as its own document with sensorId, timestamp, and value, producing millions of tiny documents per day. Queries typically retrieve readings for a sensor over a specific hour. Which schema design most improves storage efficiency and query performance for this access pattern?

Accepted Answer

Use the Bucket Pattern, grouping readings from a sensor for a time window into a single document with an array of measurements.. The Bucket Pattern is purpose-built for time-series data, grouping measurements into documents keyed by a time window. Because queries retrieve a sensor's readings for a specific hour, a bucket per sensor per hour lets one document serve the query, slashes document count and overhead, and shrinks the index footprint, improving both storage efficiency and read performance.

Answer

Enable sharding on the readings collection with sensorId as the shard key and store one reading per document.

Answer

Add a compound index on sensorId and timestamp and continue storing one reading per document.

Answer

Apply the Attribute Pattern by moving each reading's value into a key-value subdocument.

Question 8

An e-commerce application stores orders in an `orders` collection. Each order document contains an array of `items`, with each item having `productId`, `quantity`, and `price`. The application needs to frequently generate reports that sum the total revenue per product across all orders. Which schema design or feature best supports this requirement efficiently?

Accepted Answer

Use the Computed Pattern to store a `totalRevenue` field in each product document, updating it whenever an order is placed.. The Computed Pattern is designed to precompute and store aggregated values like total revenue per product. By updating the product document whenever an order is placed, the application avoids expensive aggregation scans during report generation. This pattern is ideal for frequently accessed aggregates and provides fast read performance at the cost of additional write operations.

Answer

Use the Bucket Pattern to group orders by product ID into buckets, then sum the revenue within each bucket.

Answer

Use the Extended Reference Pattern to embed product details into each order item, then use aggregation to sum revenue.

Answer

Use the Outlier Pattern to store high-volume product orders separately, then aggregate across both collections.

Question 9

A mobile banking app stores each customer's account document with an embedded array of the last 20 transactions for quick display, while the full transaction history lives in a separate transactions collection. Which data modeling consideration most directly justifies this split?

Accepted Answer

The embedded array keeps the frequently accessed working set small while the unbounded history is stored separately.. Keeping a small, bounded embedded array of recent items alongside an unbounded separate collection is a common way to keep the hot working set small and avoid unbounded document growth. The account document stays compact and fast to read, while the full history remains queryable. The other choices describe features MongoDB does not provide through embedding.

Answer

The separate collection enforces referential integrity on the transaction documents.

Answer

Storing history separately allows the account document to exceed 16MB without error.

Answer

Embedding transactions guarantees ACID transactions across the account and history collections.

Question 10

A development team is designing a schema for an e-commerce application that stores product data. Products have a set of core fields (name, price, description) that are common to all products, but different product categories have unique attributes (e.g., 'screen_size' for electronics, 'fabric' for clothing). Queries often filter on these category-specific attributes. The team wants a flexible schema that supports efficient queries on any attribute. Which TWO of the following design approaches are most appropriate? (Choose two.)

Accepted Answer

Use the Polymorphic Pattern to store all products in one collection with a 'category' field and include category-specific fields at the top level.. The Polymorphic Pattern allows a single collection to store documents with different structures, while the Attribute Pattern converts variable attributes into an indexable array of key-value pairs. Together, they provide a flexible schema that supports efficient queries on any category-specific attribute. Both patterns are widely used in MongoDB for handling heterogeneous data and are appropriate here.

Answer

Use the Bucket Pattern to group products by category into buckets of 100 documents.

Answer

Embed all possible category-specific attributes in every product document, using null for missing attributes.

Answer

Create a separate collection for each product category with its own schema and indexes.

Question 11

A healthcare application stores patient records. Each patient document includes a `medications` array of subdocuments, each with `name`, `dosage`, and `frequency`. The application needs to query patients who are taking a specific medication with a specific dosage. The array is expected to grow to hundreds of entries per patient. Which schema design best supports efficient querying and management of this data?

Accepted Answer

Move medications to a separate `medications` collection with documents referencing the patient ID, and create a compound index on `{ name: 1, dosage: 1, patientId: 1 }`.. Separating medications into their own collection prevents unbounded array growth in patient documents and enables efficient querying with a compound index. The index on `name`, `dosage`, and `patientId` supports queries for patients taking a specific medication with a specific dosage. This design scales well and simplifies management of individual medication records.

Answer

Embed the `medications` array as is, and create a multikey index on `medications.name` and `medications.dosage`.

Answer

Use the Subset Pattern to store only the most recent 10 medications in the patient document and archive older medications in a separate collection.

Answer

Use the Bucket Pattern to group medications into buckets of 50 per patient document, and index the `name` and `dosage` fields.

Question 12

An IoT platform ingests sensor readings every second from thousands of devices. The team wants to minimize the number of documents and index entries while still querying by device and time range. Which schema design best matches these requirements?

Accepted Answer

Group readings into time-bucketed documents, each holding many readings for a device over a fixed interval.. Bucketing readings into fixed-interval documents per device reduces document count and index footprint while keeping queries by device and time range efficient. Because each bucket is bounded, documents remain small and writes spread across buckets over time. The alternatives either multiply documents or create unbounded arrays that risk the size limit.

Answer

Store one document per reading with fields for deviceId, timestamp, and value.

Answer

Store each reading as a separate document and rely on a compound index on deviceId and timestamp.

Answer

Store one document per device containing an array of all readings since deployment.

Question 13

A team is deciding how to model the relationship between orders and the products each order contains. They want to optimize for the common query that retrieves an order along with the name and current price of every product in it. Which two modeling considerations best support this requirement? (Choose two.)

Accepted Answer

Embedding a copy of the product name and price inside each order line avoids a second lookup when rendering the order.. The requirement is a frequent read that needs an order plus a few product fields. Embedding just those fields as an extended reference satisfies the query with one document read, and accepting limited duplication is justified because the copied fields change rarely. Together these considerations optimize the common read path without inflating documents with unnecessary product data.

Answer

Modeling order lines as a separate collection joined by orderId avoids any duplication and is always the best choice for order reads.

Answer

Storing only the product ObjectId in each order line and resolving names and prices at read time with $lookup keeps data fully normalized.

Answer

Duplicating the entire product document into each order line ensures the order always reflects product details.

Question 14

A team is modeling a schema for an order-processing system that must support atomic updates across an order and its line items and must guarantee that reading an order never returns a partially updated set of line items. (Choose two.)

Accepted Answer

Store line items in a separate collection and use a multi-document transaction spanning the order and its items.. Atomic updates and no-partial-read guarantees come from either keeping related data in one document, where MongoDB's single-document atomicity applies, or wrapping separate documents in a multi-document transaction with snapshot isolation. References and read concern settings do not by themselves provide cross-document atomicity, and capped collections are unrelated to the requirement.

Answer

Enable majority read concern on the order collection, which by itself guarantees that line-item updates are applied atomically.

Answer

Store line items in a separate collection and rely on the order's '_id' reference to enforce atomic updates across documents.

Answer

Use a capped collection for line items so older writes are overwritten and consistency is maintained.

Question 15

A team is modeling orders and customers. Orders are frequently displayed with basic customer details such as name and email, but customer profiles are large and change often. Which approach best balances read performance with avoiding duplication problems?

Accepted Answer

Embed a small subset of frequently accessed customer fields in the order while keeping the full profile in the customers collection.. A selective embedding of only the fields commonly shown with orders keeps those reads fast and self-contained, while the authoritative, larger profile stays in its own collection to avoid widespread duplication. This balances read locality with manageable update cost. The other choices either over-duplicate volatile data or force a lookup on every read.

Answer

Embed the entire customer profile document inside every order.

Answer

Normalize customers and orders into separate collections with no duplicated fields and use $lookup for every read.

Answer

Store only a customerId reference in each order and always perform an application-side join.