• Home
  • Unlearning Joins: A Mindset Journey from Relational to Embedded Thinking 

Unlearning Joins: A Mindset Journey from Relational to Embedded Thinking 

Moving from Relational to NoSQL databases isn’t a database migration. It’s a mindset migration

We’ve seen this story play out many times. Teams that have spent years designing schemas, writing joins, and tuning relational databases carry a certain kind of muscle memory. The default approach to data feels almost instinctive: normalize it, relate it, and query it back with joins. 

That model works beautifully—until it doesn’t. 

As applications scale, the same clean relational design often becomes a bottleneck. Too many joins. Too many round trips. Too rigid to evolve. That’s usually the moment when someone says, “Maybe we should look at MongoDB.” 

And that’s where things start to get interesting. 

Most teams begin by treating MongoDB like “MySQL, but JSON.” Tables become collections. Foreign keys turn into references. JOINs are replaced with $lookup. The result? Slower queries, frustrated developers, and little to no improvement. 

That’s when the realization hits: 

Moving from Relational to NoSQL databases isn’t a database migration. 
It’s a mindset migration. 

To do it right, we have to rethink how we analyze requirements, model data, write code, and test behavior in a document world. 

This series explores that shift — not as theory, but through the lens of real-world projects and lessons learned the hard way. 

 

Part 

Title 

What it Covers 

Part 1 

Why Our Relational Mind Struggles in a Document World 

The mental shift, why joins feel “missing,” and why that’s okay 

Part 2 

Analysis: Designing for Access Patterns, Not Tables 

What to analyze before modeling anything in MongoDB 

Part 3 

Analysis: From ER Diagrams to Embedded Models 

Practical embed vs reference thinking with real examples 

Part 4 

Development: Stop Joining, Start Shaping 

Changing how we write queries, APIs, and handle data in code 

Part 5 

Development: Running the Migration (ETL, Performance & Gotchas) 

Scripts, batching, schema changes, and handling large data sets 

Part 6 

Testing: Validating What We Can’t JOIN Anymore 

How testing changes when data is embedded 

Part 7 

Testing: Edge Cases and What Happens When We Model Wrong 

Growth, updates, schema evolution, break scenarios 

Part 8 

Conclusion: The Real Win Is a Different Way of Thinking 

Final principles and lessons learned 

 

Categories: