System Design Fundamentals: Complete Guide for Technical Interviews

System Design Interview Fundamentals

System design interviews are crucial for senior engineering roles at top tech companies. This comprehensive guide covers fundamental concepts with real-world examples and step-by-step breakdowns.

System Design Interview Process

1. Clarify Requirements (5-10 minutes)
2. Estimate Scale (5 minutes)
3. High-Level Design (10-15 minutes)
4. Detailed Design (15-20 minutes)
5. Scale & Optimize (10-15 minutes)

Step 1: Requirements Clarification

Always start by asking clarifying questions:

Functional Requirements

• What are the core features?
• Who are the users?
• What platforms (web, mobile, API)?
• What's the expected user flow?

Non-Functional Requirements

• How many users?
• Expected read/write ratio?
• Consistency vs Availability trade-offs?
• Latency requirements?

Step 2: Capacity Estimation

Calculate system scale using back-of-envelope estimations:

Example: Twitter-like System

Daily Active Users (DAU): 200M
Tweets per day: 100M
Tweet reads per day: 10B

Storage per tweet: ~300 bytes
Daily storage: 100M * 300 bytes = 30GB
Annual storage: 30GB * 365 = ~11TB

Read QPS: 10B / (24 * 3600) = ~115K
Write QPS: 100M / (24 * 3600) = ~1.2K

Step 3: High-Level Design

Start with a simple architecture and identify major components:

Basic Components

• Load Balancer: Distributes incoming requests
• Web Servers: Handle HTTP requests
• Application Servers: Business logic
• Database: Data persistence
• Cache: Fast data access

Example Architecture

Client → Load Balancer → Web Servers → App Servers → Database
                                    ↓
                                  Cache

Core System Design Concepts

1. Scalability

Horizontal vs Vertical Scaling

• Vertical (Scale Up): Add more power to existing machines
• Horizontal (Scale Out): Add more machines to the pool

Stateless vs Stateful Services

• Stateless: No session data stored on server
• Stateful: Server maintains session information

2. Load Balancing

Load Balancing Algorithms

• Round Robin: Requests distributed sequentially
• Weighted Round Robin: Based on server capacity
• Least Connections: Route to server with fewest active connections
• IP Hash: Route based on client IP

Types of Load Balancers

• Layer 4 (Transport): Routes based on IP and port
• Layer 7 (Application): Routes based on content

3. Database Design

SQL vs NoSQL

Aspect	SQL	NoSQL
Schema	Fixed schema	Flexible schema
ACID	Full ACID compliance	Eventually consistent
Scaling	Vertical scaling	Horizontal scaling
Use Cases	Complex queries, transactions	Large scale, flexible data

Database Scaling Techniques

• Read Replicas: Separate read and write operations
• Sharding: Horizontal partitioning of data
• Federation: Split databases by function
• Denormalization: Trade storage for query performance

4. Caching Strategies

Cache Patterns

• Cache-Aside: Application manages cache
• Write-Through: Write to cache and database simultaneously
• Write-Behind: Write to cache first, database later
• Refresh-Ahead: Proactively refresh cache

Cache Levels

• Browser Cache: Client-side caching
• CDN: Geographic content distribution
• Reverse Proxy: Server-side caching
• Application Cache: In-memory data store
• Database Cache: Query result caching

5. Message Queues & Communication

Synchronous vs Asynchronous

• Synchronous: Real-time communication (HTTP, RPC)
• Asynchronous: Message queues (Kafka, RabbitMQ)

Message Queue Benefits

• Decoupling of services
• Improved reliability
• Better scalability
• Fault tolerance

Real-World System Design Examples

Example 1: Design Twitter

Requirements

• Users can post tweets (280 characters)
• Users can follow other users
• Users can view timeline (home and user)
• 300M users, 100M DAU

High-Level Design

Components:
- User Service (user profiles, relationships)
- Tweet Service (create, store tweets)
- Timeline Service (generate feeds)
- Notification Service (push notifications)
- Media Service (images, videos)

Database Schema

Users: user_id, username, email, created_at
Tweets: tweet_id, user_id, content, created_at
Follows: follower_id, followee_id, created_at

Timeline Generation

• Pull Model: Generate timeline on request
• Push Model: Pre-compute timelines
• Hybrid: Push for active users, pull for celebrities

Example 2: Design URL Shortener (like bit.ly)

Requirements

• Shorten long URLs
• Redirect to original URL
• Custom aliases (optional)
• Analytics (click tracking)
• 100:1 read/write ratio

URL Encoding

Base62 encoding: [a-zA-Z0-9]
7 characters = 62^7 = ~3.5 trillion URLs

Algorithm:
1. Generate unique ID (auto-increment or UUID)
2. Convert ID to Base62
3. Store mapping in database

Database Design

URLs table:
- short_url (PK)
- long_url
- user_id
- created_at
- expires_at

Analytics table:
- click_id (PK)
- short_url (FK)
- timestamp
- user_agent
- ip_address

Example 3: Design Chat System

Requirements

• One-on-one messaging
• Group chat
• Online presence
• Message history
• Push notifications

Real-time Communication

• WebSocket: Persistent connection
• Long Polling: HTTP-based alternative
• Server-Sent Events: One-way communication

Message Storage

Messages table:
- message_id (PK)
- chat_id
- sender_id
- content
- message_type
- created_at

Chats table:
- chat_id (PK)
- chat_type (direct/group)
- created_at
- updated_at

Advanced Concepts

1. Microservices Architecture

• Benefits: Independent deployment, technology diversity
• Challenges: Network complexity, data consistency
• Patterns: API Gateway, Service Discovery, Circuit Breaker

2. CAP Theorem

You can only guarantee 2 out of 3:

• Consistency: All nodes see the same data
• Availability: System remains operational
• Partition Tolerance: System continues despite network failures

3. Consistency Patterns

• Strong Consistency: All reads receive the most recent write
• Weak Consistency: Reads may not see recent writes
• Eventual Consistency: System will become consistent over time

System Design Interview Tips

1. Start Simple: Begin with basic architecture
2. Think Out Loud: Explain your reasoning
3. Ask Questions: Clarify requirements throughout
4. Consider Trade-offs: Discuss pros and cons
5. Scale Gradually: Add complexity incrementally
6. Draw Diagrams: Visual representations help
7. Estimate Numbers: Use realistic calculations
8. Identify Bottlenecks: Address potential issues

Common Mistakes to Avoid

• Jumping into details too quickly
• Not asking clarifying questions
• Ignoring non-functional requirements
• Over-engineering the solution
• Not considering failure scenarios
• Forgetting about monitoring and logging

Preparation Resources

• Books: "Designing Data-Intensive Applications" by Martin Kleppmann
• Courses: Grokking the System Design Interview
• Practice: Design popular systems (Netflix, Uber, Instagram)
• Blogs: High Scalability, AWS Architecture Center

System design interviews test your ability to architect large-scale distributed systems. Focus on understanding fundamental concepts, practice with real-world examples, and always consider trade-offs in your designs.