C100DEV Hard Questions — 25 Difficult Questions

Question 1

You have a collection with 10 million documents. Most documents have a 'status' of 'processed', but about 1% have a 'status' of 'pending'. You frequently query for 'pending' documents sorted by 'creation_date'. Which indexing strategy provides the best balance between write performance and query efficiency?

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

Accepted Answer

A partial index on { creation_date: 1 } with a partialFilterExpression of { status: 'pending' }.. Partial indexes allow you to index only a subset of documents that meet a specific filter expression. In this scenario, indexing only 'pending' documents significantly reduces the index size and the overhead of updating the index during writes for 'processed' documents. This targeted approach is more efficient than a full index when a small fraction of data is frequently accessed.

Answer

A sparse index on { status: 1, creation_date: 1 } to exclude documents missing the status field.

Answer

A compound index on { status: 1, creation_date: 1 } covering all documents in the collection.

Answer

A TTL index on 'creation_date' that automatically deletes documents once they are 'processed'.

Question 2

Which TWO of the following statements regarding wildcard indexes in MongoDB are correct?

Accepted Answer

Wildcard indexes support compound index definitions where the wildcard is a secondary field.. Wildcard indexes are powerful tools for indexing arbitrary fields in documents with unpredictable structures, but they come with trade-offs. They cannot support every query type and have specific restrictions compared to standard single-field or compound indexes. Understanding these limitations is critical for database administrators to avoid performance degradation and ensure that queries are actually utilizing the indexes as expected during application development cycles.

Answer

Wildcard indexes can be used to index all fields in a document, including those inside nested arrays.

Answer

Wildcard indexes are functionally identical to creating individual indexes on every single field in a document.

Answer

Wildcard indexes support unique constraints on the indexed fields.

Question 3

Which THREE factors influence the latency of a MongoDB transaction?

Accepted Answer

Network latency between client and primary node.. Transaction latency is affected by multiple factors within a distributed environment. Network latency between the client and the primary node, the complexity and number of operations within the transaction, and the need for majority write concern all contribute to the time taken to commit. Efficient transaction design requires balancing these factors, often by keeping transactions as short as possible to minimize lock contention and resource consumption across the cluster.

Answer

The size of the documents being queried.

Answer

The operating system used by the server.

Question 4

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 5

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 6

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 7

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 8

A developer is building a MongoDB application to store blog posts and their comments. Comments are frequently added and retrieved alongside the post, but the total number of comments per post can grow to thousands. The developer wants to optimize for read performance of the post with its comments while keeping document size manageable. Which data modeling approach is most appropriate?

Accepted Answer

Store comments in a separate collection with a postId field, and query comments by postId when needed.. Storing comments in a separate collection with a postId reference is the most scalable approach because it avoids document size limits and allows independent scaling. Embedding or referencing via an array of IDs can lead to large documents. The bucket pattern, while useful for other scenarios, does not eliminate the fundamental size constraint.

Answer

Use a bucket pattern to group comments into fixed-size buckets within the post document.

Answer

Embed all comments as an array of subdocuments within the post document.

Answer

Reference comments from the post document using an array of comment IDs.

Question 9

A developer is designing a MongoDB collection to store orders. Each order document contains an array of line items, and each line item has a product ID and quantity. The developer needs to frequently query for orders that contain a specific product ID with a quantity greater than 5. Which field should be indexed to optimize this query?

Accepted Answer

Create a compound index on { "lineItems.productId": 1, "lineItems.quantity": 1 }.. A compound multikey index on the embedded fields productId and quantity is the best choice because it allows MongoDB to efficiently evaluate both conditions within the same array element. Single-field indexes or an index on the entire array do not provide the same level of optimization. This index supports the query pattern and improves performance.

Answer

Create a multikey index on { "lineItems": 1 }.

Answer

Create a single index on { "lineItems.productId": 1 }.

Answer

Create a single index on { "lineItems.quantity": 1 }.

Question 10

An application stores customer profiles in a MongoDB collection. A developer notices that documents created by different services have inconsistent shapes: some use a string for phone, others an array of strings, and some omit the field entirely. The team wants to enforce a consistent structure for new writes while still allowing existing documents to remain. Which MongoDB feature should they use?

Accepted Answer

A JSON Schema validator attached to the collection with the $jsonSchema operator and validationLevel set to strict.. MongoDB supports schema validation through the $jsonSchema operator, configured on a collection with collMod. Setting validationLevel to strict applies the rules to all inserts and updates, so new writes must match the declared structure. Existing documents that are not modified remain untouched, which satisfies the requirement to leave current data as is while enforcing consistency going forward.

Answer

A unique index on the phone field, which forces every document to use the same BSON type for that field.

Answer

A partial index with a filter expression that excludes documents lacking the phone field.

Answer

A change stream that watches the collection and rejects documents whose shape differs from a template.

Question 11

A developer is using the MongoDB Node.js driver to execute a multi-document transaction. The transaction updates a document in the 'orders' collection and inserts a record into the 'audit' collection. After committing, the developer wants to ensure that the transaction is retried automatically if it encounters a transient error. Which driver feature should be used?

Accepted Answer

Use the driver's built-in retryable writes and transactions feature.. The MongoDB Node.js driver includes built-in support for retrying transactions that fail with transient errors. By using the driver's transaction API with a session, the driver will automatically retry the commit if it encounters a TransientTransactionError, provided the transaction is idempotent. This reduces the need for custom retry logic.

Answer

Set the write concern to { w: "majority" } to avoid transient errors.

Answer

Enable the 'retryWrites' option in the connection string and disable transactions.

Answer

Manually implement a retry loop around the transaction commit.

Question 12

A financial application stores transaction records in a MongoDB collection. Each transaction document includes a Decimal128 amount field and a Date field for the transaction time. A developer needs to query for transactions with amounts greater than 100.00 and times within the last 24 hours, and wants the queries to use indexes efficiently. Which statement about the document model and BSON types is correct for this scenario?

Accepted Answer

Date values are stored as 64-bit integers representing milliseconds since the Unix epoch, and they can be indexed and compared with range operators.. BSON Date is stored as a 64-bit integer of milliseconds since the Unix epoch, which makes it directly comparable and indexable for range queries. Decimal128 is a separate numeric type that also supports range comparisons and indexing. Together, they allow the application to filter by amount and time efficiently using appropriate indexes, without converting values to strings or avoiding range queries.

Answer

Range queries on Decimal128 fields are not supported; only equality queries can use an index on a Decimal128 field.

Answer

Decimal128 values are stored as strings, so range queries on the amount field require a text index rather than a numeric index.

Answer

Because Decimal128 and Date are both binary types, they cannot be used together in a compound index on the same collection.

Question 13

A developer is using the MongoDB Node.js driver to manage sessions for a multi-document transaction. Which TWO actions are required to ensure that the session is properly ended and resources are released? (Choose two.)

Accepted Answer

Call session.endSession() in a finally block to ensure it runs even if an error occurs.. To properly end a session in the Node.js driver, the developer must call session.endSession() after the transaction is complete, ideally within a finally block to ensure it executes even on errors. This releases the session and its resources. The withTransaction() method does not end the session automatically, so explicit ending is still required.

Answer

Set the session's causalConsistency option to false to allow immediate release.

Answer

Use the withTransaction() method to automatically handle commit and abort, which also ends the session.

Answer

Ensure that the session is not reused for other operations after ending.

Question 14

A developer is using the MongoDB Node.js driver to implement a multi-document transaction that transfers funds between two accounts in a banking application. The transaction must be resilient to transient errors and ensure that both the debit and credit operations are applied atomically. Which two of the following statements are true regarding transaction error handling and retry logic in this scenario? (Choose two.)

Accepted Answer

The developer should use the withTransaction() method provided by the Node.js driver, which handles retries and commit/abort logic automatically for TransientTransactionError and UnknownTransactionCommitResult.. The correct statements are that the driver automatically retries on TransientTransactionError, and that the withTransaction() helper handles retries and commit logic. WriteConflict is transient and can be retried, so not retrying is wrong. Manual retry is not required because the driver provides automatic retries. Ending the session is not needed for retry; the same session can be reused.

Answer

If a transaction fails with a WriteConflict error, the developer should immediately abort the transaction and not retry, as it indicates a permanent conflict.

Answer

When a transaction is aborted due to an error, the developer should call session.endSession() to release resources and then start a new session for a retry.

Answer

The developer must manually implement retry logic for TransientTransactionError because the Node.js driver does not provide automatic retries for multi-document transactions.

Question 15

A developer is using the $lookup stage to join an orders collection with a customers collection. The localField is customerId and the foreignField is _id. The pipeline must include only the customer's name and email from the joined documents, not the entire customer document. Which approach correctly shapes the joined data?

Accepted Answer

Use $lookup with a pipeline that includes $project to select only name and email from the foreign collection.. The pipeline form of $lookup allows embedding a sub-pipeline that can include $project to select only the required fields from the foreign collection. This shapes the joined data at the source, reducing the amount of data transferred and processed. It is the most efficient and correct method for including only specific fields from the joined documents.

Answer

Use $graphLookup to recursively join the collections and then filter fields with $project.

Answer

Use $lookup with localField and foreignField, then use $unwind and $replaceRoot to extract only name and email.

Answer

Use $lookup with localField and foreignField, then a subsequent $project stage to include only the desired fields from the joined array.

Question 16

A developer is using MongoDB Atlas Search to implement a search feature for an e-commerce application. They have created an Atlas Search index on the 'products' collection with a custom analyzer. They now need to write an aggregation pipeline stage to perform a search that returns products matching a query for 'wireless headphones' and also includes a count of the total number of matching documents. Which two aggregation stages should they use in their pipeline? (Choose two.)

Accepted Answer

$search. To perform an Atlas Search and get a count of matching documents, the pipeline should start with $search to execute the full-text query. Then, to count the results, the $count stage can be used, which outputs the total number of documents that passed through $search. The combination of $search and $count achieves both returning the products (if needed, but note $count replaces the documents with a count; to return both products and count, a $facet would be used, but the question only asks for the stages to include a count) and providing the count. However, the question specifically asks for two stages to use; $search and $count are the correct ones.

Answer

$match

Answer

$group

Answer

$searchMeta

Question 17

You are building a pipeline over an `events` collection to compute, per `deviceId`, the count of events and the most recent `eventTime`. Documents may contain a `deviceId` of type string, but a subset of legacy documents store the identifier as an ObjectId in the same field. You want a single group key that treats both representations consistently by producing a string for every document. Which stage should you insert before $group?

Accepted Answer

{ $addFields: { deviceKey: { $toString: "$deviceId" } } }. Grouping on a field that holds multiple BSON types creates separate groups per type, because equality is type-sensitive. Inserting a stage that coerces the identifier to a single type, such as converting every value to a string with $toString, guarantees one group per real device. The conversion stage must precede $group so the accumulator sees normalized keys.

Answer

{ $addFields: { deviceKey: { $concat: [ "$deviceId", "" ] } } }

Answer

{ $project: { deviceKey: { $ifNull: [ "$deviceId", "unknown" ] } } }

Answer

{ $addFields: { deviceKey: { $convert: { input: "$deviceId", to: "string" } } } }

Question 18

A pipeline processes a collection of financial transactions. The developer needs to calculate the cumulative sum of `amount` for each account, ordered by `date`, and output only the final cumulative sum and account ID. Which pipeline correctly computes the running total?

Accepted Answer

$sort by accountId and date, then $group with { _id: "$accountId", cumulativeSum: { $sum: "$amount" } } is not correct; the correct approach uses $setWindowFields with partitionBy and sortBy, and an accumulator.. Cumulative sums require window functions. The $setWindowFields stage can partition data by accountId, sort by date, and compute a running sum using a window that includes all previous documents. Options using $group only produce final totals, not running totals, so they are incorrect.

Answer

$sort by accountId and date, then $group with { _id: "$accountId", cumulativeSum: { $sum: "$amount" } }, then $project with { cumulativeSum: 1 }

Answer

$sort by accountId and date, then $group with { _id: "$accountId", amounts: { $push: "$amount" } }, then $project with { cumulativeSum: { $sum: "$amounts" } }

Answer

$sort by accountId and date, then $group with { _id: "$accountId", cumulativeSum: { $sum: "$amount" } }

Question 19

A developer is building an aggregation pipeline that processes a large collection of financial transactions. The pipeline includes a $group stage that accumulates sums and averages, and a $sort stage that orders results by total amount. Which two statements about memory usage and optimization are correct? (Choose two.)

Accepted Answer

The $group stage can exceed the 100 MB memory limit and will error unless allowDiskUse is enabled.. The $group stage is memory-intensive and can exceed the 100 MB limit, requiring allowDiskUse to spill to disk. Placing a $match before $group reduces the number of documents processed, lowering memory usage. These two statements correctly describe memory optimization techniques for aggregation pipelines with large datasets.

Answer

The $sort stage is always executed before $group regardless of pipeline order to optimize performance.

Answer

The $group stage automatically spills to disk when it exceeds 100 MB, so no configuration is needed.

Answer

The $sort stage can use an index if it is the first stage in the pipeline and the sort field is indexed.

Question 20

A developer has a collection named orders with documents containing a field items that is an array of subdocuments, each with productId and quantity. The developer needs to find the total quantity sold for each product across all orders. Which aggregation pipeline achieves this?

Accepted Answer

db.orders.aggregate([ { $unwind: "$items" }, { $group: { _id: "$items.productId", totalQuantity: { $sum: "$items.quantity" } } } ]). The correct pipeline unwinds the items array to flatten it, then groups by productId and sums the quantity field from the unwound documents. This accurately computes total quantity per product. The other options either fail to unwind, use the wrong accumulator, or reference a non-existent field.

Answer

db.orders.aggregate([ { $unwind: "$items" }, { $group: { _id: "$items.productId", totalQuantity: { $sum: 1 } } } ])

Answer

db.orders.aggregate([ { $unwind: "$items" }, { $group: { _id: "$items.productId", totalQuantity: { $sum: "$quantity" } } } ])

Answer

db.orders.aggregate([ { $group: { _id: "$items.productId", totalQuantity: { $sum: "$items.quantity" } } } ])