Schema design for write-heavy workloads in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Choosing the right schema for frequent writes

You have a MongoDB collection that receives thousands of writes per second. Which schema design approach helps reduce write conflicts and improves write performance?

A Use a schema with small, flat documents and avoid embedding large arrays to reduce document size and locking.

B Use a normalized schema with references to separate documents to avoid large document sizes.

C Embed all related data in a single document to minimize the number of writes.

D Store all data in a single large document to reduce the number of documents and simplify queries.

💡 Hint

Think about how MongoDB locks documents during writes and how document size affects write speed.

Small, flat documents reduce the chance of write conflicts and improve write throughput because MongoDB locks at the document level. Embedding large arrays or storing all data in one document can cause large document sizes and slow writes.

❓ query_result

intermediate

Result of updating embedded documents in a write-heavy schema

Consider a MongoDB collection where user profiles embed an array of login timestamps. You run this update:

db.users.updateOne({ _id: 1 }, { $push: { logins: ISODate() } })

What is the expected effect on write performance if the logins array grows very large?

A Write performance degrades because the entire document must be rewritten when the array grows large.

B Write performance remains stable because MongoDB only updates the array element.

C Write performance improves because the array is indexed automatically.

D Write performance is unaffected because MongoDB uses row-level locking.

💡 Hint

Consider how MongoDB handles document updates and the impact of large arrays on document size.

MongoDB rewrites the entire document on update. Large arrays increase document size, causing slower writes and more disk I/O.

📝 Syntax

advanced

Identify the correct schema design for high write throughput

Which MongoDB schema design below best supports a write-heavy workload where each write is a new event that must be stored quickly?

A Store all events in a single document with an ever-growing array of events.

B Embed events inside user documents and update the entire user document on each event.

C Use a capped collection with a fixed size to store events, overwriting old events automatically.

D Store each event as a separate small document in a collection with an index on the event timestamp.

💡 Hint

Think about how document size and indexing affect write speed and storage.

Storing each event as a separate small document allows fast inserts and avoids large document rewrites. Indexing on timestamp supports efficient queries.

🔧 Debug

advanced

Why does this write-heavy schema cause slow writes?

A MongoDB collection stores user activity logs embedded inside user documents as arrays. Over time, writes slow down significantly. What is the most likely cause?

A MongoDB does not support arrays inside documents, causing errors.

B The arrays grow too large, causing document rewrites and increased disk I/O.

C The collection lacks an index on the user ID field.

D The server is running out of RAM due to too many indexes.

💡 Hint

Consider how MongoDB handles document updates and the impact of large embedded arrays.

Large arrays cause the entire document to be rewritten on each update, slowing down writes as document size grows.

🧠 Conceptual

expert

Optimizing schema for write-heavy workloads with sharding

You have a MongoDB cluster with sharding enabled to handle a write-heavy workload. Which shard key choice best supports even write distribution and avoids write hotspots?

A Use a monotonically increasing field like a timestamp as the shard key.

B Use a hashed value of a frequently updated field as the shard key.

C Use a compound shard key combining user ID and a random suffix.

D Use a constant value as the shard key for all documents.

💡 Hint

Think about how shard keys affect data distribution and write load balancing.

A compound shard key with a random suffix spreads writes across shards evenly, avoiding hotspots caused by monotonically increasing keys.

Practice

1. Which schema design approach is best for a MongoDB collection with very frequent writes?

easy

A. Use many small documents instead of one large nested document

B. Use one large document with deeply nested arrays

C. Use a single document for all data to reduce queries

D. Use only embedded documents without references

Solution

1. Step 1: Understand write-heavy workload needs

   Write-heavy workloads benefit from smaller documents to reduce update size and locking.

2. Step 2: Compare schema designs

   Large nested documents cause bigger writes and slower updates, while many small documents keep writes fast and simple.

3. Final Answer:

   Use many small documents instead of one large nested document -> Option A

4. Quick Check:

   Write-heavy = small docs [OK]

Hint: Choose small documents for fast writes [OK]

Common Mistakes:

• Thinking one big document is faster for writes
• Ignoring update size impact on performance
• Assuming embedded documents always improve speed

2. Which of the following is the correct way to define a MongoDB schema optimized for frequent writes?

easy

A. Embedding large arrays inside documents for all related data

B. Splitting data into multiple small collections with references

C. Using a single document with nested objects for all user data

D. Storing all data in one collection without indexes

Solution

1. Step 1: Identify schema syntax for write optimization

   Splitting data into small collections with references reduces document size and write contention.

2. Step 2: Evaluate options

   Embedding large arrays or single large documents slows writes; no indexes hurt query but not write speed.

3. Final Answer:

   Splitting data into multiple small collections with references -> Option B

4. Quick Check:

   Small collections + references = write-friendly [OK]

Hint: Split data, use references for write speed [OK]

Common Mistakes:

• Embedding large arrays causing slow writes
• Ignoring indexing impact on queries
• Using one big document for all data

3. Given this schema design for a write-heavy app:

{ _id: 1, user: "Alice", posts: [ {id: 1, text: "Hello"}, {id: 2, text: "World"} ] }

What is the main drawback when updating the text of a single post?

medium

A. Only the single post is updated, so writes are fast

B. MongoDB automatically splits the document for faster writes

C. The entire document must be rewritten, slowing writes

D. Updates fail because nested arrays are not allowed

Solution

1. Step 1: Understand document update behavior in MongoDB

   MongoDB rewrites the whole document on update, even if only one nested element changes.

2. Step 2: Analyze impact on write-heavy workloads

   Large documents with nested arrays cause slower writes because the entire document is rewritten.

3. Final Answer:

   The entire document must be rewritten, slowing writes -> Option C

4. Quick Check:

   Nested arrays cause full document rewrite [OK]

Hint: Nested arrays cause full document rewrite [OK]

Common Mistakes:

• Assuming only changed nested element updates
• Believing MongoDB splits documents automatically
• Thinking updates fail on nested arrays

4. You designed a schema with large embedded arrays for a write-heavy collection. Writes are slow. What is the best fix?

medium

A. Split embedded arrays into separate collections with references

B. Add more indexes to speed up writes

C. Increase document size limit to hold more data

D. Use a single large document to reduce queries

Solution

1. Step 1: Identify cause of slow writes

   Large embedded arrays cause big document rewrites, slowing writes.

2. Step 2: Apply schema design fix

   Splitting arrays into separate collections reduces document size and speeds up writes.

3. Final Answer:

   Split embedded arrays into separate collections with references -> Option A

4. Quick Check:

   Split large arrays to speed writes [OK]

Hint: Split large arrays into collections [OK]

Common Mistakes:

• Adding indexes to fix write speed
• Increasing document size limit
• Using one big document for all data

5. You have a write-heavy social app where users post comments frequently. Which schema design best balances fast writes and easy reads?

hard

A. Use a single document for all users and comments combined

B. Embed all comments inside each user document as a large array

C. Store all comments in one document per post with nested arrays

D. Store each comment as a separate document with a user reference

Solution

1. Step 1: Analyze write-heavy app needs

   Frequent writes require small documents to avoid large rewrites and locking.

2. Step 2: Evaluate schema options for balance

   Storing comments as separate documents with user references keeps writes fast and allows easy querying.

3. Final Answer:

   Store each comment as a separate document with a user reference -> Option D

4. Quick Check:

   Separate docs + references = fast writes + easy reads [OK]

Hint: Use separate documents with references for comments [OK]

Common Mistakes:

• Embedding all comments causing slow writes
• Using one big document for all data
• Nesting comments deeply inside posts