Preparing for System Design : Starting point

We have prepared an elaborate list of terms you need to learn as you start your system design journey. We are not going to explain these terms to you but simply list them out. We might cover them in detail in future posts. So subscribe to the blog if you want them.

If you do not know what any of these terms mean, it means you are not prepared. So spend time learning it. Use it as a checklist.

1. Fundamental Concepts

Scalability: Ability of a system to handle growing amounts of data and traffic.
Reliability: Ability of a system to consistently perform its intended function without failure.
Availability: The percentage of time a system is operational and accessible.
Consistency: Ensuring all users see the same data at the same time.
Efficiency: Optimal use of resources (CPU, memory, bandwidth) to achieve performance.
Latency: Time taken for a request to be processed and a response received.
Throughput: Number of requests a system can handle per unit of time.
CAP Theorem: States that it's impossible for a distributed system to simultaneously provide Consistency, Availability, and Partition tolerance; you must choose two.
ACID Properties: (Atomicity, Consistency, Isolation, Durability) A set of properties that guarantee reliable database transactions.

2. Architectural Patterns

Client-Server: A model where clients request services from a central server.
Microservices: Breaking down an application into small, independent services.
Message Queues: Components that allow asynchronous communication between services.
Load Balancing: Distributing traffic across multiple servers to prevent overload.
Caching: Storing frequently accessed data in a fast-access location.
Databases (SQL, NoSQL): Organized collections of data for storage and retrieval.
- Relational Databases (SQL): Structured data organized in tables with relationships.
- NoSQL Databases: Flexible schema for unstructured or semi-structured data.
CDN (Content Delivery Network): A geographically distributed network of servers that store copies of website assets to deliver content faster to users.
Saga Pattern : A distributed asynchronous processing pattern.

3. Specific Technologies & Concepts

REST APIs: A standard for building web services that use HTTP methods (GET, POST, PUT, DELETE).
HTTP: (Hypertext Transfer Protocol) The foundation of data communication on the web.
DNS (Domain Name System): Translates domain names into IP addresses.
TCP/IP: The suite of protocols that govern the internet.
WebSockets: Enables real-time, two-way communication between client and server.
Sharding: Horizontal partitioning of a database to distribute data across multiple machines.

4. Design Considerations

Vertical Scaling: Increasing the resources of a single server (CPU, RAM).
Horizontal Scaling: Adding more servers to a system to handle increased load.
Database Indexing: Creating data structures to speed up data retrieval.
Data Replication: Creating copies of data to improve availability and fault tolerance.
Rate Limiting: Controlling the rate of traffic to a system to prevent abuse and overload.
Circuit Breaker: A pattern to prevent cascading failures in a distributed system.

Databases

MySQL: Open-source, widely used, good for general purpose web applications.
PostgreSQL: Advanced features, strong SQL compliance, good for complex data models.
Oracle: Enterprise-grade, highly scalable, expensive but robust.
MS SQL Server: Microsoft ecosystem, good integration with .NET, strong for transactional workloads.
MongoDB: Flexible schema, good for document-oriented data, popular for web and mobile apps.
Cassandra: Highly available, fault-tolerant, good for distributed systems and high write throughput.
Redis: In-memory, very fast, excellent for caching and real-time data.
Amazon DynamoDB: Fully managed, scalable, pay-as-you-go, integrated with the AWS ecosystem.
Neo4j: Handles relationships efficiently, good for social networks, recommendation engines.
Elasticsearch: Powerful search and analytics, good for log analysis, full-text search.
ClickHouse: High-performance analytics, good for large datasets and complex queries.

Caches

1. CPU Cache: Small, very fast memory within the CPU that stores frequently used instructions and data. (e.g., L1, L2, L3 caches)

2. Disk Cache: Portion of RAM used to store frequently accessed data from the hard drive.

3. Web Cache (Browser Cache): Stores website assets (images, scripts, etc.) locally on the user's browser to speed up page loading.

4. Server-Side Cache: Caches data on the server to reduce database load and improve response times. Object Cache: Stores specific data objects like database query results. Page Cache: Caches entire web pages or fragments of pages. * Opcode Cache: Stores precompiled code to avoid redundant compilation.

5. CDN Cache: Stores copies of website content on servers geographically closer to users for faster delivery.

6. DNS Cache: Stores DNS records locally to speed up website lookups.

7. Distributed Cache: A cache that is spread across multiple servers, often used in large-scale systems. (e.g., Redis, Memcached)

Microservices

1. Microservice: A small, independent, and loosely coupled service that performs a specific business function.

2. API Gateway: A single entry point for all clients, handling routing, authentication, and rate limiting for microservices.

3. Service Discovery: A mechanism for microservices to locate and communicate with each other dynamically.

4. Service Mesh: A dedicated infrastructure layer for managing communication between microservices, providing features like load balancing, service discovery, and security.

5. Containerization: Packaging a microservice and its dependencies into a container (e.g., Docker) for easy deployment and portability.

6. Orchestration: Automating the deployment, scaling, and management of microservices, often using tools like Kubernetes.

7. Circuit Breaker: A pattern to prevent cascading failures by stopping requests to a failing service.

8. Distributed Tracing: Tracking requests across multiple microservices to monitor performance and identify bottlenecks.

9. Event-Driven Architecture: Microservices communicate through events, enabling asynchronous and decoupled interactions.

10. CQRS (Command Query Responsibility Segregation): Separating read and write operations to improve performance and scalability.

Message Queues

Message Queue: A temporary storage buffer for messages waiting to be processed.
Producer: An application that creates and sends messages to a queue.
Consumer: An application that receives and processes messages from a queue.
Queue Depth: The number of messages currently held in a queue.
Message Broker: A middleware component that manages the flow of messages between producers and consumers. (e.g., RabbitMQ, Kafka)
Acknowledgement (ACK): A signal from a consumer to the queue that a message has been successfully processed.
Dead-letter Queue: A queue that stores messages that failed to be processed.
Message Priority: Assigning different levels of importance to messages for processing order.
Message Durability: Ensuring messages are not lost even if the message broker fails.
Message Ordering: Guaranteeing messages are processed in the order they were sent.