YouTube video: https://youtu.be/1nENigGr-a0?si=FSS7E4ByShNHg3ic

System design is fundamentally about making right trade-offs—whether building a system from scratch or scaling existing applications. Understanding these core trade-offs empowers engineers and architects to make better architectural decisions tailored to specific application needs.

1. Trade-Offs in Data Storage: SQL vs NoSQL Databases

Overview

Data storage choices involve fundamental trade-offs between structure, consistency, scalability, and flexibility. SQL and NoSQL databases represent two distinct approaches:

• SQL Databases
  • Strengths: Strong consistency, structured schemas, powerful query capabilities
  • Trade-off: Difficult to scale horizontally and schema changes are complex
  • Use case: When you need rock-solid transactions and complex queries (e.g., banking systems)
• NoSQL Databases
  • Strengths: Flexible schema, easy horizontal scalability
  • Trade-off: Sacrifices some consistency guarantees and complex queries
  • Use case: When you need to scale massively with evolving data models (e.g., social media)

Key Insight

This isn’t about which is better universally. Instead, it's about understanding the application's specific needs and choosing based on whether consistency and structure or scalability and flexibility are priorities.

2. Database Design: Normalization vs Denormalization

Concepts

• Normalization
  • Organizes data into separate tables to minimize redundancy
  • Ensures each piece of data is stored only once
  • Optimizes data integrity and storage efficiency
  • Example: Keeping user information in one table linked by IDs
• Denormalization
  • Intentionally duplicates data across tables to avoid costly joins
  • Enhances read performance and query speed
  • Increases complexity of write operations and risks potential inconsistencies

Practical Application

Most large-scale systems evolve from fully normalized designs toward strategic denormalization to improve query performance where necessary. This reflects a shift in priorities as an application matures, moving from correctness and simplicity to performance and scale.

3. Distributed Systems: The CAP Theorem Trade-Off