The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Embed related data when it is bounded and usually read or updated with its parent. Reference it when it grows without a clear limit, changes independently, is queried on its own, or would otherwise be duplicated repeatedly. MongoDB treats this as a workload-specific schema decision: start with the operations your application needs, not a blanket rule that every relationship must use the same pattern.
What is the difference between embedding and referencing?
Embedding stores related values inside the same MongoDB document, usually as embedded documents or an array. Referencing stores related documents separately and records a link—typically the other document’s _id—in the document that needs the relationship.
For example, a patron document could contain an array of the patron’s addresses if the application usually displays them together. By contrast, books can refer to a separate publisher document when publisher details are shared across books and may change independently. MongoDB describes these as different ways to model relationships, not as a universal better-versus-worse choice. See its data modeling guidance.
How should you choose?
List the application’s frequent and critical reads and writes, then shape the schema around them. MongoDB’s guidance is to understand the operations an application runs, map the related data, and choose a structure for those query patterns. A schema that works well for one workload may not fit another.
#1 Best Overall
| Decision factor | Embedding tends to fit | Referencing tends to fit |
|---|---|---|
| Read pattern | The parent and related data are usually returned together. | The related entity is often queried by itself. |
| Growth and cardinality | The number of related items is small and bounded. | The related set is high-cardinality or has no clear upper bound. |
| Updates | The related values are read or updated together. | The related values change frequently or independently. |
| Duplication | Duplication is limited or useful to serve reads. | Repeated copies would be costly or difficult to keep consistent. |
| Document size and transfer | The combined document stays manageable for the application. | Combining the data would make documents too large or resource-intensive. |
| Relationship shape | The relationship is naturally a “contains” or parent-context relationship. | The relationship is complex many-to-many or part of a large hierarchy. |
These are documented decision factors, not performance guarantees. Compare the actual queries, indexes, document sizes, and write mix in your application before concluding that either design will be faster.
When should you embed documents in MongoDB?
When related data is usually needed with its parent
If an application normally fetches a parent and a small group of related values together, embedding can return them in one database operation. MongoDB gives a patron with two addresses as an example: if the application displays the patron and all addresses together, keeping them in one document matches that read pattern. See MongoDB’s embedding guidance.
When a set of child items has a clear bound
Embedding is a good candidate for small, limited child sets that belong in the parent’s context. The important qualification is that the set needs a practical upper bound: an array that grows indefinitely can make a document and its indexes increasingly costly to work with.
When related values need a single-document atomic update
MongoDB identifies single-document atomic updates as a benefit of embedding. If the application must change related values together as one atomic write, storing them in one document can make that operation straightforward. This is a design benefit, not a promise that every embedded schema improves overall performance.
Rank #3
When should you reference data?
When related records grow or are queried independently
Use separate documents when the child set has no clear limit, the related records are frequently accessed on their own, or the relationship is a large hierarchy or complex many-to-many association. Separating those records avoids packing a potentially growing collection into one parent document.
When shared information changes independently
If many documents use the same related information, storing a copy in every one can make updates harder: each copy may need to be changed and kept consistent. A reference to a separate record avoids that repeated data. MongoDB’s publisher-and-books example illustrates why repeating publisher details in every book may be undesirable. See MongoDB’s referencing guidance.
Rank #4
When duplicated values create consistency work
Embedding can keep a value in one location when it belongs to one parent, but deliberately copying shared values across many embedded documents creates a consistency obligation. Referencing can be the better fit when those shared values change independently and the application needs one authoritative record.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What does a reference require at read time?
A manual reference usually stores the target document’s _id. The application can then issue another query to fetch that document when needed; MongoDB describes this as simple and sufficient for most relationship use cases. The reference is not an automatic foreign-key join.
Best Value
For normalized data, MongoDB aggregation includes stages such as $lookup and $graphLookup for joining or traversing collection data in supported circumstances. Whether to fetch separately in application code or use an aggregation depends on the query and workload.
MongoDB also documents DBRefs, which carry collection metadata and can optionally include database metadata. They are not automatically resolved and require additional queries to resolve; absent a compelling reason to use them, MongoDB recommends manual references. See the manual and DBRef reference documentation.
How do unbounded arrays affect the choice?
MongoDB documents must be smaller than 16 mebibytes. An unbounded array can eventually approach that limit, consume more resources, and affect index performance. When child records may keep accumulating, storing them in separate documents and referencing the parent is one documented remedy. The size limit is a product constraint, not a performance benchmark; consult the manual for the MongoDB server version you deploy. See MongoDB’s unbounded-array guidance.
What should you validate before committing to a schema?
- Identify the application’s most frequent and most important reads and writes.
- Check whether related records are usually needed alongside the parent or queried independently.
- Estimate how large each related set can become, and whether that bound is real.
- Consider which values change together and which change independently.
- Account for any repeated data and the work required to keep copies consistent.
- Test representative queries and writes using realistic document sizes, indexes, and data volumes.
MongoDB’s documentation explains the trade-offs, but it does not establish one pattern as faster for every application. The right choice is the one that serves the workload while keeping growth, updates, and data consistency manageable.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
