Data modeling

Enables atomic reads and writes of related data in a single document operation, avoiding multi-document transactions and join overhead.

Document database design: modeling a blog post with embedded comments; E-commerce catalog: storing product variants inside a product document; Content management: nesting author profiles within article documents

MongoDB, Couchbase, CouchDB, Firestore, document-oriented NoSQL databases, JSON-based data stores

embed related sub-documents within a parent document → avoid joins → optimize for read locality

• embedded documents
• nested arrays
• denormalization
• document schema
• $lookup
• single-document atomicity
• BSON

• Normalized relational tables with foreign keys — better for many-to-many but requires joins
• References via document IDs — better for large sub-collections but requires multi-document fetches

Embedding unbounded arrays that grow without limit — causes document size limits (16MB in MongoDB) and poor write performance; Embedding data that is frequently updated independently — leads to write amplification and conflicts; Treating compound documents as a replacement for all joins — some queries genuinely need cross-document references

Embedded sub-documents (nested within parent) vs. referenced documents (linked by ID); Denormalization (duplicating data for read speed) vs. compound documents (grouping related data); Aggregation pipelines (server-side joins) vs. compound documents (client-side single fetch)

Coming from SQL/relational databases: may default to normalizing data into separate tables — document databases reward embedding related data that is always read together; Coming from OOP: may try to model every entity as a separate document — compound documents favor grouping entities with strong containment relationships

• embedded documents
• denormalization
• document schema design
• single-document atomicity
• aggregation pipelines

When NOT to use: when sub-collections are unbounded or frequently accessed independently; Performance: single-document reads are atomic and fast, but large embedded arrays degrade write performance; Boundary conditions: document size limits (16MB in MongoDB), array element limits, and index coverage of embedded fields all constrain embedding depth

Enables single-round-trip reads of complete entity graphs, reduces need for application-level joins, and provides atomic updates for related data without distributed transactions.

Compound documents are like Russian nesting dolls — related data lives inside the parent, retrieved all at once, no assembly required.

Aggregation pipelines and $lookup for cross-document queries; Schema validation rules for compound document structure