Anti-patterns to avoid in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this MongoDB query?

Consider a collection users with documents containing name and age. What will this query return?

MongoDB

db.users.find({age: {$gt: 30}}).limit(2)

A Syntax error due to incorrect query

B Returns all users with age greater than 30

C Returns 2 users regardless of age

D Returns the first 2 users with age greater than 30

💡 Hint

Remember that limit() restricts the number of documents returned.

The query filters users with age > 30 and limits the result to 2 documents.

🧠 Conceptual

intermediate

Why is embedding large arrays in documents an anti-pattern?

In MongoDB, what is a major problem with embedding very large arrays inside a single document?

A It improves query speed by avoiding joins

B It can cause the document size to exceed the 16MB limit, leading to errors

C It automatically shards the data across servers

D It compresses the data to save space

💡 Hint

Think about MongoDB's maximum document size.

MongoDB documents have a 16MB size limit. Large arrays can exceed this, causing errors.

📝 Syntax

advanced

Which option causes a syntax error in MongoDB aggregation?

Identify the aggregation pipeline stage that will cause a syntax error.

MongoDB

db.orders.aggregate([
  {$match: {status: 'shipped'}},
  {$group: {_id: '$customerId', total: {$sum: '$amount'}}},
  {$sort: {total: -1}}
])

A {$group: {_id: '$customerId', total: {$sum: 'amount'}}}

B {$group: {_id: '$customerId', total: {$sum: '$amount'}}}

C {$sort: {total: -1}}

D {$match: {status: 'shipped'}}

💡 Hint

Check the syntax of the $sum operator argument.

The $sum operator requires a field path starting with '$'. Missing '$' causes syntax error.

❓ optimization

advanced

Which indexing strategy avoids the anti-pattern of slow queries?

Given a collection with frequent queries filtering by category and sorting by price, which index is best to optimize performance?

A Create a compound index on <code>category</code> and <code>price</code>

B Create a single-field index on <code>price</code>

C Create a single-field index on <code>category</code>

D No index needed; rely on collection scan

💡 Hint

Think about queries that filter and sort on multiple fields.

A compound index on both fields supports filtering and sorting efficiently, avoiding slow queries.

🔧 Debug

expert

Why does this MongoDB update not modify any documents?

Given the collection products and this update command, why are no documents updated?

MongoDB

db.products.updateMany({tags: 'sale'}, {$set: {discount: 10}})

A The <code>$set</code> operator is used incorrectly

B The update command syntax is invalid

C The <code>tags</code> field is an array, so matching a string directly fails

D The <code>updateMany</code> method requires a third argument

💡 Hint

Consider how MongoDB matches array fields in queries.

Matching a string directly to an array field requires using $elemMatch or the string itself if exact match is intended. If tags is an array, matching 'sale' as a string may fail if the array contains objects or different types.

Practice

1. Which of the following is an anti-pattern to avoid in MongoDB when designing your data model?

easy

A. Splitting large data into separate collections

B. Storing huge arrays inside a single document

C. Using indexes to speed up queries

D. Keeping documents shallow with minimal nesting

Solution

1. Step 1: Understand data model best practices

   MongoDB recommends avoiding very large arrays inside one document because it can slow down queries and updates.

2. Step 2: Identify the anti-pattern

   Options A, B, and D are good practices, but storing huge arrays in one document is an anti-pattern.

3. Final Answer:

   Storing huge arrays inside a single document -> Option B

4. Quick Check:

   Huge arrays in one document = anti-pattern [OK]

Hint: Large arrays in one document slow performance [OK]

Common Mistakes:

• Thinking indexes are bad
• Believing deep nesting is good
• Ignoring document size limits

2. Which of the following MongoDB document structures is syntactically correct, uses a structured object for address, and avoids the deep nesting anti-pattern?

easy

A. { name: "Alice", address: { city: "NY", zip: 10001 } }

B. { name: "Bob", address: { city: { name: "LA", code: { zip: 90001 } } } }

C. { name: "Carol", address: { city: { name: { code: { zip: 12345 } } } } }

D. { name: "Dave", address: "New York" }

Solution

1. Step 1: Check document nesting levels

   { name: "Alice", address: { city: "NY", zip: 10001 } } has shallow nesting: address contains city and zip directly.

2. Step 2: Identify deep nesting anti-pattern

   Options A and C have multiple nested objects inside city, which is deep nesting. { name: "Dave", address: "New York" } uses a string for address, which is valid but less structured.

3. Final Answer:

   { name: "Alice", address: { city: "NY", zip: 10001 } } -> Option A

4. Quick Check:

   Shallow nesting = correct syntax and good practice [OK]

Hint: Avoid multiple nested objects inside one field [OK]

Common Mistakes:

• Confusing deep nesting with valid nested objects
• Using strings instead of objects for structured data
• Ignoring syntax errors in nested documents

3. Given a MongoDB collection with documents containing a large array field, what is the likely result of querying without indexes?

medium

A. Automatic splitting of large arrays into smaller parts

B. Fast query response even with large arrays

C. Syntax error in query execution

D. Slow query performance due to collection scan

Solution

1. Step 1: Understand query execution without indexes

   Without indexes, MongoDB performs a collection scan, checking every document.

2. Step 2: Impact of large arrays on query speed

   Large arrays increase document size, making scans slower and more resource-intensive.

3. Final Answer:

   Slow query performance due to collection scan -> Option D

4. Quick Check:

   No index + large arrays = slow queries [OK]

Hint: No index means full scan, slow with big arrays [OK]

Common Mistakes:

• Assuming queries are always fast
• Expecting automatic array splitting
• Confusing syntax errors with performance issues

4. You have a MongoDB document with a very large array that is frequently updated. What is the best way to fix performance issues?

medium

A. Split the large array into multiple documents in a separate collection

B. Keep the large array inside the same document and update it directly

C. Remove indexes to speed up updates

D. Nest the array deeper inside the document

Solution

1. Step 1: Identify the problem with large arrays and frequent updates

   Large arrays inside one document cause slow updates and can hit document size limits.

2. Step 2: Choose the best solution to improve performance

   Splitting the array into multiple documents in a separate collection reduces document size and update cost.

3. Final Answer:

   Split the large array into multiple documents in a separate collection -> Option A

4. Quick Check:

   Split large data for frequent updates [OK]

Hint: Split big arrays into separate documents [OK]

Common Mistakes:

• Updating large arrays in one document
• Removing indexes which slows queries
• Increasing nesting depth unnecessarily

5. You want to design a MongoDB schema for a social media app where users have many posts and comments. Which design avoids anti-patterns?

hard

A. Store all posts and comments as large arrays inside each user document

B. Nest comments deeply inside each post inside the user document

C. Use separate collections for users, posts, and comments with references

D. Keep all data in one collection with mixed document types

Solution

1. Step 1: Analyze the data size and update frequency

   Users can have many posts and comments, which can grow large and update often.

2. Step 2: Choose schema design to avoid large arrays and deep nesting

   Using separate collections with references avoids huge arrays and deep nesting, improving performance and scalability.

3. Final Answer:

   Use separate collections for users, posts, and comments with references -> Option C

4. Quick Check:

   Separate collections avoid large arrays and deep nesting [OK]

Hint: Separate collections for related large data sets [OK]

Common Mistakes:

• Putting all data in one document
• Deep nesting of comments inside posts
• Mixing document types in one collection