System Design Basics

Load Balancer

Distributes incoming requests across multiple servers to improve reliability and scalability.

Reverse Proxy

Server that receives client requests and forwards them to backend servers, hiding internal structure.

Horizontal Scaling

Adding more servers to handle increased load.

Vertical Scaling

Upgrading server hardware to increase capacity.

Microservices

Breaking an application into independent, loosely coupled services.

Monolith

A single unified codebase or deployment handling all functionality.

Service-Oriented Architecture

A design where services communicate over a network.

API Gateway

Entry point that routes requests to multiple services and handles cross-cutting concerns like auth.

REST API

Architectural style using HTTP verbs and resources.

GraphQL

Query language allowing clients to specify exactly the data they need.

gRPC

High-performance RPC framework using HTTP/2 and Protocol Buffers.

Message Queue

A system to decouple producers and consumers using asynchronous messages.

Event-Driven Architecture

System where services communicate via events rather than direct calls.

Pub/Sub

Publishers send messages to topics, subscribers receive them asynchronously.

Caching

Storing frequently accessed data in fast storage to reduce latency.

CDN (Content Delivery Network)

Geographically distributed servers delivering content closer to users.

Database Sharding

Splitting data across multiple databases for scale.

Database Replication

Keeping multiple copies of data synchronized for high availability.

Master-Slave Replication

One primary DB for writes, secondary for reads.

Leader-Follower Replication

Modern term for master-slave architecture.

Failover

Automatically switching to a backup system when a primary fails.

CAP Theorem

Trade-off between Consistency, Availability, and Partition tolerance in distributed systems.

Consistency Models

Strong, eventual, causal, etc., levels of data consistency.

ACID Properties

Atomicity, Consistency, Isolation, Durability in transactions.

BASE Properties

Basically Available, Soft state, Eventual consistency for distributed systems.

Idempotency

Repeating a request yields the same result.

Statelessness

Each request contains all the information needed; no session stored on server.

Stateful Service

Service maintains session or state information across requests.

Rate Limiting

Restricting the number of requests a client can make.

Circuit Breaker Pattern

Stops calling a failing service to prevent cascading failures.

Bulkhead Isolation

Partitioning system resources so failure in one area doesn’t sink the whole system.

Retry with Backoff

Retrying failed operations after increasing delays.

Service Discovery

Automatic detection of service instances and their endpoints.

Load Shedding

Dropping requests gracefully under overload.

Graceful Degradation

System remains partially functional under stress.

Autoscaling

Automatically adding/removing compute resources based on demand.

Containerization

Packaging applications and dependencies in isolated units (Docker).

Orchestration

Managing multiple containers and services (Kubernetes).

Reverse DNS

Mapping IP addresses back to hostnames, useful in logging/security.

Health Checks

Probes that determine if a service is running properly.

Blue-Green Deployment

Two production environments to deploy with zero downtime.

Canary Deployment

Rolling out changes to a small subset of users first.

Feature Flag

Toggling features on/off without redeployment.

Data Partitioning

Splitting data logically to improve performance.

Load Testing

Simulating high traffic to test system performance.

Stress Testing

Testing beyond normal load to find breaking points.

Latency vs Throughput

Latency is response time; throughput is requests per second.

Cold Start

Initial latency when spinning up new resources.

Warm Cache

Cache already populated with frequently used data.

Cache Eviction Policies

LRU, LFU, FIFO for removing old cache items.

Database Index

Data structure speeding up queries at the cost of extra writes.

Query Optimization

Tweaking SQL or DB structure to run faster.

Connection Pooling

Reusing DB connections to reduce overhead.

Distributed Transactions

Coordinating a transaction across multiple systems.

Two-Phase Commit

Protocol ensuring distributed transaction consistency.

Saga Pattern

Coordinating distributed transactions via a series of compensating actions.

Event Sourcing

Storing changes as a sequence of events rather than state snapshots.

Command Query Responsibility Segregation (CQRS)

Separating read and write models for performance and clarity.

Write-Ahead Log

Logging changes before applying them to ensure durability.

Time-to-Live (TTL)

Automatic expiration of cache or data entries.

Data Lake

Centralized repository for raw data at scale.

Data Warehouse

Optimized DB for analytics and reporting.

Batch Processing

Processing large data sets at scheduled times.

Stream Processing

Real-time processing of data flows.

Backpressure

Mechanism to handle overwhelming data streams.

Rate Matching

Adjusting producer/consumer rates to avoid overload.

Security: Authentication

Verifying user identity (passwords, tokens).

Security: Authorization

Determining user’s permissions.

OAuth2

Delegated authorization standard.

JWT (JSON Web Token)

Compact token for secure information exchange.

API Keys

Simple method for authenticating API calls.

Input Validation

Checking incoming data to prevent injection attacks.

SQL Injection

Attack inserting malicious SQL into queries.

XSS (Cross-Site Scripting)

Injecting malicious scripts into web pages.

CSRF (Cross-Site Request Forgery)

Tricking authenticated users into unwanted actions.

HTTPS / TLS

Encrypted communication between client and server.

Rate Limiting for Security

Limiting brute force attacks or abuse.

Audit Logging

Recording key actions for security and debugging.

IAM (Identity and Access Management)

Framework for managing users and permissions.

Secrets Management

Securely storing API keys and credentials.

Zero Trust Architecture

No implicit trust, always verify.

Immutable Infrastructure

Don’t modify servers after deployment; redeploy instead.

Observability

Ability to measure internal states from outputs.

Monitoring

Tracking metrics like CPU, latency, errors.

Logging

Recording system events for debugging.

Tracing

Following a request through distributed systems.

Metrics Aggregation

Collecting system stats over time.

Alerting

Notifications when metrics cross thresholds.

Chaos Engineering

Deliberately breaking parts of system to test resilience.

Distributed Consensus

Protocols like Raft or Paxos for leader election.

Eventual Consistency

Updates propagate eventually across all nodes.

Strong Consistency

All reads see the most recent write.

Idempotent Retry APIs

Ensuring safe replays of requests.

Backoff Strategies

Increasing wait time between retries to reduce load.

Immutable Data Patterns

Avoid in-place modification for consistency.

Shadow Traffic

Sending real traffic to new systems without affecting users.

Service Mesh

Dedicated infrastructure layer for service-to-service communication.

Edge Computing

Processing closer to users to reduce latency.

Multi-Region Deployment

Hosting in multiple regions for resilience.

Disaster Recovery

Planning backups and failover for catastrophic failures.