Stop Joining Tables In Your “Modular” Monolith

Why It Matters

Hidden data-layer coupling erodes modular architecture, increasing maintenance risk and hampering evolution; aligning data models to business functions reduces cross-module dependencies and preserves agility.

Summary

The video warns that joining tables across modules in a modular monolith hides dangerous coupling at the database level. While a simple SQL join between sales and warehouse seems convenient, it creates implicit dependencies that undermine module boundaries and make future schema changes risky. Using APIs can expose and manage those dependencies better, but still couples services in different ways and adds migration overhead. The speaker argues teams should instead question the actual business requirement—e.g., use an Available-to-Promise function rather than raw inventory counts—to keep responsibilities and data ownership aligned within module boundaries.

Original Description

Modular monoliths are all the rage, but is yours actually just a "Big Ball of Mud" with a clean coat of paint? In this video, I break down the hidden trap of joining tables across module boundaries and why database-level coupling is just as dangerous as tight coupling in your code.

We’ll explore the "Simple Join" trap, why internal APIs provide better evolvability, and a real-world example to show how aligning with business functions can eliminate the need for cross-boundary queries entirely.

🔗 Kurrent

https://kurrent.io

🔔 Subscribe: https://www.youtube.com/channel/UC3RKA4vunFAfrfxiJhPEplw?sub_confirmation=1

💥 Join this channel to get access to a private Discord Server and any source code in my videos.

🔥 Join via Patreon

https://www.patreon.com/codeopinion

✔️ Join via YouTube

https://www.youtube.com/channel/UC3RKA4vunFAfrfxiJhPEplw/join

📝 Blog: https://codeopinion.com

👋 Twitter: https://twitter.com/codeopinion

✨ LinkedIn: https://www.linkedin.com/in/dcomartin/

📧 Weekly Updates: https://mailchi.mp/63c7a0b3ff38/codeopinion

00:00 - The Illusion of the Modular Monolith

00:43 - The "Simple" Join: A Hidden Coupling Trap

02:09 - Why Database-Level Coupling is Dangerous

03:01 - Solving Coupling with Internal APIs

04:19 - Requirements vs. Reality: Available to Promise (ATP)

06:38 - Architectural Trade-offs & Evolvability

08:36 - Final Thoughts: Is your Monolith a "Big Ball of Mud"?