Day 01 Of System Design

Basic Of System Design:- why do we need it ?

Need for System Design

System design is essential because it provides a blueprint for building complex, scalable, and reliable applications. Without proper design, software systems often face significant challenges:

Key Reasons Why System Design is Necessary

Problem Area	Why System Design Addresses It
Scalability	Ensures the system can handle a growing number of users, transactions, or data volume by planning for distributed architectures, load balancing, and efficient resource utilization.
Reliability and Fault Tolerance	Identifies single points of failure and incorporates redundancy, failover mechanisms, and robust error handling to ensure continuous availability and resilience.
Maintainability	Creates modular, well-documented, and logically structured components, making it easier for new teams to understand, debug, and update the codebase over time.
Performance	Determines the optimal data structures, algorithms, and infrastructure choices (like caching or message queues) to meet latency and throughput requirements.
Cost Efficiency	Allows for the selection of appropriate technologies and infrastructure (e.g., cloud services vs. self-hosted servers), preventing over-provisioning or unnecessary complexity.
Security	Integrates security best practices—such as authentication, authorization, and data encryption—from the initial phase, rather than trying to patch them on later.
Interoperability	Defines clear interfaces (APIs) and protocols so that different components or services can communicate effectively, often allowing for the integration of third-party services.

Types Of System Design

High Level Design (HLD)

Low Level Design (LLD)

High Level Design

This is a rough overview of the the system architecture how the data will flow, or may how the system will work,

This image show the overview working of each part of system it. If we talk about the individual like how login will work then it is LLD, how load balancer work for this project/system, how the data will store etc they are the LLD,

Simple Shabdon Mein: HLD ka matlab hai ki upper-upper se structure kaisa hoga woh batana, depth mein nahi jaane ka, bro!

Definition:- a functional requirement into a non-functional blueprint that details how the system will be built to meet quality attributes like performance, reliability, and scale.

Low Level Design

Low Level Design = how each small part of the system is built internally.

If HLD = city map, then

LLD = house blueprint (rooms, doors, wiring)

High Level Design (HLD)	Low Level Design (LLD)
Big picture	Internal details
Components	Classes & objects
Services	Methods & logic
Databases	Tables & fields
APIs list	API request/response

System Design — Most Common Definitions & Terms (Interview-Ready)

1 Latency

Definition:
Time taken to complete one request.

Unit: milliseconds (ms)

Example:
User clicks “Login” → page loads in 120 ms

Note:- “Lower latency means faster user experience.”

2 Throughput

Definition:
Number of requests the system can handle per unit time.

Unit: requests/second (RPS), TPS

Example:
System handles 10,000 requests/second

Note:- Latency vs Throughput:

Latency = speed of one request
Throughput = how many requests

3 Turnaround Time

Definition:
Total time from request submission to final response, including waiting.

Example:
Upload video → processing → confirmation = 30 seconds

Used more in batch systems & async jobs

4 Availability

Definition:
System is up and usable when needed.

Formula:

Availability = Uptime / (Uptime + Downtime)

Example:
99.9% availability = ~8.7 hours downtime/year

Note:- “High availability ensures minimal downtime.”

5 Reliability

Definition:
System works correctly over time without failure.

Example:
Payment deducted once, not twice

Note:- Availability ≠ Reliability
System can be available but return wrong data.

6 Consistency

Definition:
All users see the same data at the same time.

Example:
Balance = ₹1000
Every device shows ₹1000

In Short:- agar kuchh update hua ho toh sabhi jagh update ho ek sath, jaise ki tumne apne dost ko paisa bheja lekin tumahare account se paisa kata , aur tumhare dost ke account main update nahi hua vic versa.

7 Strong Consistency

Definition:
Read always returns latest write.

Example:
Bank balance after transfer

Slower
Accurate

8 Eventual Consistency

Definition:
Data becomes consistent after some time.

Example:
Instagram likes count

Fast
Temporary mismatch

9 Scalability

Definition:
Ability to handle more users/load by adding resources.

Types:

Vertical (bigger server)
Horizontal (more servers

10 Redundancy

Definition:
Duplicate components to avoid failure.

Example:
Multiple DB replicas

11 Idempotency

Definition:
Same request multiple times → same result.

Example:
Retry payment request → money deducted once

12 Caching

Definition:
Storing frequently used data for faster access.

Example:
User profile stored in Redis

13 Cache Hit / Miss

Hit: data found in cache
Miss: fetch from DB

14 Rate Limiting

Definition:
Restrict number of requests per user.

Example:
100 requests/minute/user

15 Load Balancing

Definition:
Distribute traffic across servers.

Example:
Nginx / AWS ALB

16 Bottleneck

Definition:
Slowest component limiting system performance.

Matlab:- mano ki tum class main baithe ho or board se tum kuchh apne notes main likh rahe ho, tum kaafi tej student ho, tumhe sab kuchh jaldi,se aa jata hai lekin tumhari class mai kuchh student hai jo bahut deehre likhte hai, jisse teacher ko, wait krna padta hai,

Example:
DB becomes slow → whole system slow

17 CAP Theorem(Consistency, Availability & Partition Tolerance )

In distributed systems, you can guarantee only 2 of 3:

Most systems choose AP or Cp

Term	Meaning
Consistency	Same data everywhere
Availability	Always responds
Partition Tolerance	Works despite network failure

Fundamental Concepts for System Design

To begin our journey into system design, we will first establish a foundation by learning the basic terms.

Next, we will cover:

Types of Systems: Understanding different system paradigms, such as centralized and distributed systems.
System Design Architectures: Exploring common architectural styles (e.g., Monolithic, Microservices, Serverless).

What Should Be Next:

After covering the fundamental concepts and architectures, the logical next step is to Design a Simple System.

Proposed Next Step:

3. Simple System Design Example: Login and Authorization

This will involve applying the learned concepts to design the components and flow for a basic user authentication and authorization system.

Day 01: System Design - Basics