Schema design for read-heavy workloads in MongoDB - Step-by-Step Execution

Concept Flow - Schema design for read-heavy workloads

Identify read-heavy workload

↓

Choose schema design strategy

↓

Embed related data

↓

Query data directly

↓

Fast read performance

↓

Monitor and adjust

Start by identifying if reads dominate. Then choose embedding for fewer reads or referencing for smaller docs. Finally, query accordingly and monitor performance.

Execution Sample

MongoDB

db.orders.insertOne({
  _id: 1,
  customer: { name: "Alice", email: "[e-mail]" },
  items: [{ product: "Book", qty: 2 }]
})

Insert an order document embedding customer info and items for fast reads.

Execution Table

Step	Action	Data State	Effect on Reads
1	Insert order with embedded customer and items	{_id:1, customer:{name:'Alice', email:'[e-mail]'}, items:[{product:'Book', qty:2}]}	One read fetches all needed data
2	Query order by _id	Returns full order with customer and items embedded	Fast read, no joins needed
3	Update customer email inside order	Modify embedded customer.email in order document	Write affects whole order document
4	Insert order with referenced customer ID	{_id:2, customerId: 123, items:[{product:'Pen', qty:5}]}	Reads require join or multiple queries
5	Query order and lookup customer by ID	Order data plus separate customer data fetched	Slower read due to extra query or $lookup
6	End	Schema choice affects read speed and complexity	Embedding favors read speed; referencing favors data size and write flexibility

💡 Execution stops after showing how embedding vs referencing affects read performance

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	After Step 5	Final
order document	empty	{_id:1, customer:{name:'Alice', email:'[e-mail]'}, items:[{product:'Book', qty:2}]}	{_id:1, customer:{name:'Alice', email:'[e-mail]'}, items:[{product:'Book', qty:2}]}	{_id:2, customerId:123, items:[{product:'Pen', qty:5}]}	{_id:2, customerId:123, items:[{product:'Pen', qty:5}]}	Order data varies by embedding or referencing

Key Moments - 3 Insights

Why does embedding customer data speed up reads?

Because all needed data is in one document, so one query fetches everything without extra lookups, as shown in execution_table step 2.

Why might referencing customer data slow down reads?

Because it requires additional queries or $lookup to fetch related data, adding overhead as seen in execution_table step 5.

What is a trade-off of embedding data for read-heavy workloads?

Writes become heavier since updating embedded data means rewriting the whole document, demonstrated in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the effect on reads after inserting an order with embedded customer data (Step 1)?

A Reads require multiple queries

B One read fetches all needed data

C Reads are slower due to joins

D No data is fetched

💡 Hint

Check the 'Effect on Reads' column at Step 1 in execution_table

At which step does updating embedded customer data happen?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the step describing modifying embedded customer.email in execution_table

If you switch from embedding to referencing, how does the read performance change according to the execution_table?

A Reads require extra queries or $lookup, slowing them down

B Reads become faster with fewer queries

C Reads do not change

D Reads stop working

💡 Hint

Compare Steps 2 and 5 in execution_table for read performance differences

Concept Snapshot

Schema design for read-heavy workloads:
- Embed related data to reduce number of reads
- Referencing keeps documents smaller but needs joins
- Embedding speeds reads but can slow writes
- Choose based on read vs write priorities
- Monitor and adjust schema as workload changes

Full Transcript

This visual execution shows how schema design affects read-heavy workloads in MongoDB. First, we identify if reads dominate. Then we choose embedding to store related data together or referencing to keep documents smaller. Embedding allows fetching all data in one query, speeding reads, but updates require rewriting the whole document. Referencing needs extra queries or $lookup, slowing reads but improving write flexibility. The execution table traces inserting orders with embedded or referenced customer data, querying them, and updating embedded fields. Variable tracking shows how order documents change. Key moments clarify why embedding speeds reads and referencing slows them. The quiz tests understanding of these effects. The snapshot summarizes key points for quick reference.

Practice

1. Which schema design approach is best for read-heavy workloads in MongoDB?

easy

A. Embed related data in the same document to reduce read operations

B. Use references for all data to keep documents small

C. Normalize data like in relational databases

D. Store all data in separate collections regardless of usage

Solution

1. Step 1: Understand read-heavy workload needs

   Read-heavy workloads benefit from fewer queries and faster data retrieval.

2. Step 2: Choose schema design for fast reads

   Embedding related data in one document reduces the need for multiple queries, speeding up reads.

3. Final Answer:

   Embed related data in the same document to reduce read operations -> Option A

4. Quick Check:

   Embedding = faster reads [OK]

Hint: Embed related data for fast reads in read-heavy apps [OK]

Common Mistakes:

• Choosing referencing for all data slows reads
• Normalizing like SQL increases read complexity
• Separating all data causes many queries

2. Which of the following is the correct way to embed an array of comments inside a blog post document in MongoDB?

easy

A. { title: 'Post', comments: [{ user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' }] }

B. { title: 'Post', comments: 'user: Alice, text: Nice!' }

C. { title: 'Post', comments: { user: 'Alice', text: 'Nice!' } }

D. { title: 'Post', comments: ['user: Alice', 'text: Nice!'] }

Solution

1. Step 1: Identify correct array embedding syntax

   Embedding an array of subdocuments requires an array of objects inside the field.

2. Step 2: Check each option's structure

   { title: 'Post', comments: [{ user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' }] } correctly uses an array of objects for comments; others use incorrect types or formats.

3. Final Answer:

   { title: 'Post', comments: [{ user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' }] } -> Option A

4. Quick Check:

   Array of objects = correct embedding [OK]

Hint: Use array of objects to embed multiple related items [OK]

Common Mistakes:

• Using string instead of array for multiple comments
• Embedding a single object instead of an array
• Using array of strings instead of objects

3. Given this MongoDB document for a product with embedded reviews:

{ _id: 1, name: 'Gadget', reviews: [{ user: 'Ann', rating: 5 }, { user: 'Ben', rating: 4 }] }

What will be the result of this query?

db.products.findOne({ _id: 1 }, { name: 1, 'reviews.rating': 1 })

medium

A. { name: 'Gadget', reviews: [{ rating: 5 }, { rating: 4 }] }

B. { _id: 1, name: 'Gadget', reviews: [{ rating: 5 }, { rating: 4 }] }

C. { _id: 1, name: 'Gadget' }

D. { _id: 1, name: 'Gadget', reviews: [{ user: 'Ann', rating: 5 }, { user: 'Ben', rating: 4 }] }

Solution

1. Step 1: Understand projection with dot notation

   Using 'reviews.rating': 1 includes only the rating field inside each review subdocument.

2. Step 2: Analyze returned fields

   The query returns _id, name, and reviews with only rating fields (user excluded).

3. Final Answer:

   { _id: 1, name: 'Gadget', reviews: [{ rating: 5 }, { rating: 4 }] } -> Option B

4. Quick Check:

   Projection with dot notation = filtered subfields [OK]

Hint: Use dot notation in projection to include subfields only [OK]

Common Mistakes:

• Expecting full subdocuments when projecting subfields
• Forgetting _id is included by default
• Assuming projection excludes _id without explicit exclusion

4. You designed a schema embedding user addresses inside user documents, but queries on addresses are slow. What is the likely problem?

medium

A. MongoDB does not support embedding arrays

B. Embedding always makes queries slower

C. You must store addresses in a separate database

D. Addresses should be referenced separately if they are large or updated often

Solution

1. Step 1: Identify embedding drawbacks

   Embedding large or frequently changing data can cause large documents and slow updates or queries.

2. Step 2: Choose referencing for large or mutable data

   Referencing addresses separately keeps user documents small and improves query speed on addresses.

3. Final Answer:

   Addresses should be referenced separately if they are large or updated often -> Option D

4. Quick Check:

   Large mutable data = use referencing [OK]

Hint: Reference large or changing data to keep documents small [OK]

Common Mistakes:

• Assuming embedding always improves speed
• Thinking MongoDB disallows embedding arrays
• Believing separate databases are needed for performance

5. You have a read-heavy app showing user profiles with many posts. Posts change often, but profiles rarely do. How should you design the schema for fast reads?

hard

A. Embed user profile data inside each post document

B. Embed posts inside user profiles despite frequent changes

C. Store user profiles and posts in separate collections, referencing posts from profiles

D. Duplicate posts data inside profiles and update both on changes

Solution

1. Step 1: Analyze data change frequency

   Posts change often; embedding them inside profiles would cause large documents and frequent updates.

2. Step 2: Choose referencing for frequently changing large data

   Storing posts separately and referencing them keeps profiles small and reads fast.

3. Step 3: Avoid data duplication to prevent sync issues

   Duplicating posts in profiles causes update complexity and inconsistency risks.

4. Final Answer:

   Store user profiles and posts in separate collections, referencing posts from profiles -> Option C

5. Quick Check:

   Frequent changes = referencing large data [OK]

Hint: Reference frequently changing data, embed stable data [OK]

Common Mistakes:

• Embedding frequently changing posts inside profiles
• Duplicating data causing sync problems
• Embedding profiles inside posts which is illogical