C100DEV Practice Test 14 — 15 Questions

Question 1

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?

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

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 2

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 3

An IoT platform stores sensor readings in a collection `readings` with fields `deviceId`, `timestamp`, and `value`. The collection is large and grows continuously. Queries typically retrieve the most recent readings for a specific device, filtering by `deviceId` and sorting by `timestamp` descending. The operations team wants to minimize index size while still supporting these queries efficiently. Which index strategy best meets this requirement?

Accepted Answer

Create a compound index on { deviceId: 1, timestamp: -1 } only, which supports the equality filter and the descending sort without an additional index.. The query pattern filters by `deviceId` and sorts by `timestamp` descending. A compound index on `{ deviceId: 1, timestamp: -1 }` directly supports both the equality match and the sort, allowing MongoDB to return results in order without an in-memory sort. This single index is sufficient, minimizing index size and avoiding unnecessary additional indexes.

Answer

Create a hashed index on { deviceId: 1 } combined with a single-field index on { timestamp: -1 } to distribute data and support sorting.

Answer

Create a compound index on { deviceId: 1, timestamp: -1 } and a separate single-field index on { timestamp: -1 } to handle global sorts.

Answer

Create a single-field index on { deviceId: 1 } only, because the sort on `timestamp` can always be performed in memory efficiently.

Question 4

A developer is configuring an Atlas Search index on a collection of product documents. The index definition uses a dynamic mapping. Which two statements accurately describe the behavior or configuration of Atlas Search indexes in this scenario? (Choose two.)

Accepted Answer

Atlas Search indexes are stored in a separate search process and are updated asynchronously from the primary replica set.. Dynamic mapping in Atlas Search automatically indexes supported field types without per-field declarations, and the search index itself is maintained by a separate process that receives changes asynchronously from the replica set. The other statements misstate requirements or availability: analyzers are not mandatory for every string under dynamic mapping, Atlas Search is unavailable outside Atlas, and underscore-prefixed fields like _id are not dynamically indexed.

Answer

Dynamic mappings index fields whose names begin with an underscore, such as _id, by default.

Answer

Atlas Search indexes can be created on any MongoDB deployment, including self-managed community servers.

Answer

Setting dynamic to true requires also specifying analyzers for every string field in the collection.

Question 5

You are modeling an IoT telemetry system in MongoDB. Each sensor device emits a reading every 5 seconds, and the application most often queries the last 24 hours of readings for a single device. You want to minimize the number of index entries and document reads per query. Which schema design should you choose?

Accepted Answer

Store readings in per-device, per-hour bucket documents that hold a readings array, with a compound index on { deviceId: 1, startTime: -1 }.. Bucketing groups many measurements into a single document, so a fixed time-window query for one device scans a small, predictable number of documents and index keys. Grouping by device and hour keeps buckets bounded in size, avoiding the 16MB limit, while the index on deviceId and startTime supports fast range filtering. The other designs either explode the number of documents or introduce unbounded growth and joins.

Answer

Store readings in a separate collection and use $lookup to join them to a device document at query time.

Answer

Store each reading as its own document with a compound index on { deviceId: 1, timestamp: -1 }.

Answer

Store all readings for a device in a single document containing a readings array that grows indefinitely.

Question 6

A development team is designing a MongoDB collection to store sensor readings. Each reading document contains a `sensorId`, a `timestamp`, and a `value`. The team expects billions of readings and needs to optimize for fast queries that retrieve the latest reading for a specific sensor. They decide to use a compound index. Which index key order best supports this query pattern?

Accepted Answer

{ sensorId: 1, timestamp: -1 }. The optimal compound index for retrieving the latest reading per sensor is `{ sensorId: 1, timestamp: -1 }`. This allows MongoDB to seek directly to the sensor's entries and return them in descending time order, so the first result is the most recent. It also supports equality on sensorId and sort on timestamp, enabling an efficient, non-blocking query.

Answer

{ timestamp: 1, sensorId: 1 }

Answer

{ value: 1, sensorId: 1 }

Answer

{ sensorId: 1, value: 1 }

Question 7

You have a collection of sensor readings where each document includes a timestamp field `recordedAt` and a temperature field `tempC`. You need to generate a report that groups readings into 15-minute intervals and calculates the average temperature per interval. Which aggregation expression should you use to create the grouping key?

Accepted Answer

{ $dateTrunc: { date: "$recordedAt", unit: "minute", binSize: 15 } }. The $dateTrunc operator is designed to truncate dates to a specified unit and bin size, making it ideal for grouping into intervals. It handles all date components automatically, ensuring correct 15-minute buckets. The other options either do not round, are overly complex, or operate on partial components, leading to incorrect grouping.

Answer

{ $dateFromParts: { year: { $year: "$recordedAt" }, month: { $month: "$recordedAt" }, day: { $dayOfMonth: "$recordedAt" }, hour: { $hour: "$recordedAt" }, minute: { $multiply: [ { $floor: { $divide: [ { $minute: "$recordedAt" }, 15 ] } }, 15 ] } } }

Answer

{ $subtract: [ "$recordedAt", { $mod: [ { $minute: "$recordedAt" }, 15 ] } ] }

Answer

{ $dateToString: { format: "%Y-%m-%d %H:%M", date: "$recordedAt" } }

Question 8

A logistics application stores shipment records in a collection named `shipments`. Each document includes a `status` field (e.g., "in_transit", "delivered") and a `delivery_date` field. The development team frequently runs a query that filters on `status` and sorts by `delivery_date` in ascending order. They want to create a compound index to optimize this query. Which index should they create?

Accepted Answer

{ status: 1, delivery_date: 1 }. For a query that filters on one field and sorts on another, the index should list the equality-filtered field first, followed by the sort field. This allows MongoDB to use the index for both the filter and the sort, avoiding an expensive in-memory sort. The index { status: 1, delivery_date: 1 } matches this pattern and is optimal.

Answer

{ status: 1 }

Answer

{ delivery_date: 1, status: 1 }

Answer

{ status: 1, delivery_date: -1 }

Question 9

An application writes documents to a `metrics` collection where each document contains an embedded array `samples` of subdocuments with fields `value` and `unit`. A query filters on `samples.unit` and `samples.value` together, expecting both conditions to match the same array element. The developer creates { "samples.unit": 1, "samples.value": 1 }. Which behavior should the developer expect from this index?

Accepted Answer

The index is valid and can be used, but it may return documents where `unit` and `value` match different array elements unless the filter is written carefully.. Compound multikey indexes are allowed when the indexed paths belong to the same array, so the index can be created and used to reduce the candidate set. The critical limitation is that the index does not preserve element pairing: a document can match `samples.unit` and `samples.value` from different elements. Using `$elemMatch` restores the same-element requirement during document filtering.

Answer

The index is automatically converted into a wildcard index covering all subdocument fields.

Answer

The index enforces that `unit` and `value` come from the same element, returning only matching pairs.

Answer

The index cannot be created because compound multikey indexes are disallowed on array fields.

Question 10

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 11

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.

Question 12

A developer is building a Node.js application that connects to a MongoDB replica set. The application must ensure that every read operation sees a consistent snapshot of the data, even if other clients are concurrently modifying documents. Which read concern level should be used for these reads?

Accepted Answer

"snapshot". The "snapshot" read concern provides a consistent snapshot of the data across multiple documents, ensuring that the application sees a stable view even with concurrent writes. Other read concerns like "local", "majority", or "available" do not offer this snapshot isolation, so they are unsuitable for the stated requirement.

Answer

"local"

Answer

"available"

Answer

"majority"

Question 13

A developer needs to quickly inspect the contents of a MongoDB collection and run ad-hoc queries during development. The developer prefers a command-line interface that supports JavaScript syntax and allows direct interaction with the database. Which MongoDB tool should be used?

Accepted Answer

mongosh. mongosh is the official command-line shell for MongoDB, supporting JavaScript syntax and enabling direct interaction with the database for ad-hoc queries and administration. It is the appropriate tool for a developer who prefers a command-line interface. The other options are either GUI-based, cloud services, or specialized utilities not intended for interactive querying.

Answer

MongoDB Compass

Answer

MongoDB Database Tools

Answer

MongoDB Atlas

Question 14

A developer is exploring a 'reviews' collection and wants to retrieve only the 'author' and 'rating' fields from every review document, without the _id field, to reduce the payload sent to the application. Which query accomplishes this?

Accepted Answer

db.reviews.find({}, { author: 1, rating: 1, _id: 0 }). Projection is the second parameter of find, and mixing inclusion values with _id: 0 is the standard way to return a subset of fields without the identifier. Passing fields as the first argument turns them into a filter, and using exclusion values in a projection drops the very fields the developer needs.

Answer

db.reviews.find({}, { author: true, rating: true })

Answer

db.reviews.aggregate([{ $project: { author: 0, rating: 0, _id: 0 } }])

Answer

db.reviews.find({ author: 1, rating: 1, _id: 0 })

Question 15

A reporting service reads from the 'sensors' collection, which holds millions of documents each containing an 'active' boolean field. The service queries only for documents where 'active' is true and reads a handful of fields. A developer wants the query to avoid scanning documents that are inactive. Which index should be created to support this access pattern most directly?

Accepted Answer

db.sensors.createIndex({ active: 1 }). An equality filter on a single boolean field is best served by a single-field index on that field, which allows the planner to seek directly to the matching entries and fetch only relevant documents. A compound index led by _id, a text index, or a sparse variant cannot provide that access path, because the query does not supply a usable prefix or field type for those structures.

Answer

db.sensors.createIndex({ active: 1 }, { sparse: true })

Answer

db.sensors.createIndex({ _id: 1, active: 1 })

Answer

db.sensors.createIndex({ active: "text" })