Jonas Notes

Cheat Sheet

11 min read

System Design Components and Their Use Cases

API Gateway

  • Use Cases/Problems:
    • Unified API access: Centralizes client requests.
    • Security: Manages authentication and authorization.
  • System Design Questions:
    • Design an API gateway for microservices.
    • Implement secure and scalable API access.
  • Component: API Gateway
  • What it Solves:
    • Single entry point, manages authentication and routing.
  • Caveats/Issues:
    • Can become a bottleneck, adds latency.
  • Mitigations:
    • Use multiple gateways with load balancing.
    • Implement rate limiting and caching.
    • Use circuit breakers and retries.
  • Examples of Tools:
    • Kong, Apigee, AWS API Gateway

Load Balancer

  • Use Cases/Problems:
    • High traffic websites: Ensures uptime and balances load.
    • Scalable APIs: Distributes incoming requests.
  • System Design Questions:
    • Design a scalable web application.
    • Build a highly available online service.
  • Component: Load Balancer
  • What it Solves:
    • Distributes traffic across workers, improves reliability and availability.
  • Caveats/Issues:
    • Single point of failure, adds complexity.
  • Mitigations:
    • Use multiple load balancers in different regions.
    • Implement health checks.
    • Use DNS-based load balancing.
  • Examples of Tools:
    • Nginx, HAProxy, AWS ELB

SQL Database

  • Use Cases/Problems:
    • Financial transactions: Requires ACID compliance.
    • Complex queries: Needs structured and relational data.
  • System Design Questions:
    • Design a financial transaction system.
    • Create a scalable relational database.
  • Component: SQL Database
  • What it Solves:
    • Strong ACID properties, structured data, complex queries.
  • Caveats/Issues:
    • Limited scalability, schema management.
  • Mitigations:
    • Implement sharding.
    • Use read replicas.
    • Employ clustering and partitioning.
  • Examples of Tools:
    • MySQL, PostgreSQL, MS SQL Server

NoSQL Database

  • Use Cases/Problems:
    • Large-scale data: Supports horizontal scaling.
    • Unstructured data: Flexible schema adapts to changes.
  • System Design Questions:
    • Design a large-scale user profile store.
    • Create a scalable data storage solution.
  • Component: NoSQL Database
  • What it Solves:
    • Flexible schema, horizontal scalability, high performance.
  • Caveats/Issues:
    • Eventual consistency, limited transaction support.
  • Mitigations:
    • Use consistency settings (e.g., quorum reads/writes).
    • Design for idempotent operations.
    • Implement conflict resolution strategies.
  • Examples of Tools:
    • MongoDB, Cassandra, DynamoDB

Data Replication

  • Use Cases/Problems:
    • High availability: Ensures data is replicated and available.
  • System Design Questions:
    • Design a data replication strategy.
    • Implement a highly available database system.
  • Component: Data Replication
  • What it Solves:
    • Ensures data durability, to ensure system availability.
  • Caveats/Issues:
    • Increases costs, consistency issues.
  • Mitigations:
    • Use asynchronous replication.
    • Implement conflict resolution.
    • Use multi-master replication.
  • Examples of Tools:
    • AWS RDS standby (synchronous), AWS RDS Read Replicas (asynchronous), MongoDB Replica Set (asynchronous)

Cache

  • Use Cases/Problems:
    • High read load: Reduces latency for frequent reads.
    • Session storage: Speeds up access to session data.
  • System Design Questions:
    • Design a high-performance caching layer.
    • Optimize read-heavy workload.
  • Component: Cache
  • What it Solves:
    • Reduces latency, decreases load on databases.
  • Caveats/Issues:
    • Cache consistency issues, potential for stale data.
  • Mitigations:
    • Implement cache invalidation strategies.
    • Use Time-to-Live (TTL) settings.
    • Employ write-through or write-back caching.
  • Examples of Tools:
    • Redis, Memcached

In-Memory Database

  • Use Cases/Problems:
    • Real-time analytics: Requires fast data access.
    • Leaderboards: High-speed data retrieval is crucial.
  • System Design Questions:
    • Design a real-time analytics system.
    • Create a fast leaderboard service.
  • Component: In-Memory Database
  • What it Solves:
    • Extremely fast data retrieval, reduces latency.
  • Caveats/Issues:
    • Volatile storage, high memory cost.
  • Mitigations:
    • Enable persistence options.
    • Use hybrid storage models (in-memory + disk).
    • Implement data backup strategies.
  • Examples of Tools:
    • Redis, Memcached

Message Broker

  • Use Cases/Problems:
    • Event streaming: Manages high-throughput data streams.
    • Real-time processing: Facilitates real-time data flows.
  • System Design Questions:
    • Design a real-time event streaming platform.
    • Implement a reliable messaging system.
  • Component: Message Broker
  • What it Solves:
    • Facilitates message exchange, supports multiple patterns.
  • Caveats/Issues:
    • Bottleneck potential, delivery guarantees.
  • Mitigations:
    • Use scalable brokers with partitions.
    • Implement backpressure handling.
    • Monitor message broker performance.
  • Examples of Tools:
    • Apache Kafka, RabbitMQ, ActiveMQ

Distributed Queue

  • Use Cases/Problems:
    • Event-driven systems: Manages asynchronous events.
    • Microservices: Decouples service communication.
  • System Design Questions:
    • Design an event-driven architecture.
    • Create a reliable task processing system.
  • Component: Distributed Queue
  • What it Solves:
    • Manages asynchronous communication, decouples components.
  • Caveats/Issues:
    • Message ordering and delivery guarantees.
  • Mitigations:
    • Use message brokers with strong ordering guarantees.
    • Implement idempotent message processing.
    • Use message deduplication techniques.
  • Examples of Tools:
    • Apache Kafka, RabbitMQ, AWS SQS

Microservices

  • Use Cases/Problems:
    • Large applications: Enhances modularity and scalability.
    • Continuous delivery: Facilitates independent deployment.
  • System Design Questions:
    • Design a scalable microservices architecture.
    • Build a modular, independently deployable system.
  • Component: Microservices
  • What it Solves:
    • Improves modularity, independent deployment.
  • Caveats/Issues:
    • Increased communication complexity.
  • Mitigations:
    • Use service meshes.
    • Implement standardized APIs.
    • Use centralized logging and monitoring.
  • Examples of Tools:
    • Docker, Kubernetes, Istio

Service Registry

  • Use Cases/Problems:
    • Microservices: Enables service discovery.
    • Dynamic environments: Tracks changing service instances.
  • System Design Questions:
    • Design a service discovery mechanism.
    • Implement dynamic service registration.
  • Component: Service Registry
  • What it Solves:
    • Tracks services and their instances.
  • Caveats/Issues:
    • High availability required, consistency issues.
  • Mitigations:
    • Use distributed service registries.
    • Implement regular health checks.
    • Use consensus algorithms for consistency.
  • Examples of Tools:
    • Consul, Eureka, Zookeeper

CDN (Content Delivery Network)

  • Use Cases/Problems:
    • Content-heavy sites: Improves load times for users.
    • Global reach: Distributes content across regions.
  • System Design Questions:
    • Design a content delivery system.
    • Optimize a global website’s performance.
  • Component: CDN
  • What it Solves:
    • Reduces latency, improves load times.
  • Caveats/Issues:
    • Cache invalidation complexity, cost.
  • Mitigations:
    • Implement cache purging strategies.
    • Use regional CDNs.
    • Monitor CDN performance and hit rates.
  • Examples of Tools:
    • Cloudflare, Akamai, AWS CloudFront

Data Warehouse

  • Use Cases/Problems:
    • Business intelligence: Centralizes analytics data.
    • Historical analysis: Supports complex querying over large datasets.
  • System Design Questions:
    • Design a data warehouse for analytics.
    • Build a scalable business intelligence platform.
  • Component: Data Warehouse
  • What it Solves:
    • Centralizes data, supports complex queries.
  • Caveats/Issues:
    • High storage and maintenance costs.
  • Mitigations
    • Use data compression and partitioning.
    • Implement data lifecycle management.
    • Use cloud-based, scalable data warehouses.
  • Examples of Tools:
    • Amazon Redshift, Snowflake, Google BigQuery

Search Engine

  • Use Cases/Problems:
    • E-commerce sites: Provides fast product search.
    • Large datasets: Enables full-text search over extensive data.
  • System Design Questions:
    • Design a product search system.
    • Implement a scalable search solution.
  • Component: Search Engine
  • What it Solves:
    • Enables fast search over large datasets.
  • Caveats/Issues:
    • Indexing and maintenance required.
  • Mitigations:
    • Implement efficient indexing strategies.
    • Use distributed search architectures.
    • Optimize search queries and relevance.
  • Examples of Tools:
    • Elasticsearch, Solr, Algolia

File Storage

  • Use Cases/Problems:
    • Media storage: Handles large files like images and videos.
    • Backup solutions: Stores and retrieves backups.
  • System Design Questions:
    • Design a scalable file storage system.
    • Implement a reliable backup solution.
  • Component: File Storage
  • What it Solves:
    • Scales with data growth, handles unstructured data.
  • Caveats/Issues:
    • Backup and redundancy required, retrieval latency.
  • Mitigations:
    • Use distributed file systems.
    • Implement multi-region replication.
    • Use lifecycle policies for data management.
  • Examples of Tools:
    • AWS S3, Google Cloud Storage, HDFS

ETL Pipeline

  • Use Cases/Problems:
    • Data warehousing: Prepares data for analysis.
    • Data migration: Transforms data from multiple sources.
  • System Design Questions:
    • Design an ETL pipeline for a data warehouse.
    • Build a reliable data integration system.
  • Component: ETL Pipeline
  • What it Solves:
    • Facilitates data integration and analysis.
  • Caveats/Issues:
    • Complex to build and maintain.
  • Mitigations:
    • Use managed ETL services.
    • Implement monitoring and error handling.
    • Use data validation and transformation tools.
  • Examples of Tools:
    • Apache Nifi, AWS Glue, Talend

Monitoring System

  • Use Cases/Problems:
    • System reliability: Monitors uptime and performance.
    • Issue detection: Alerts for anomalies and failures.
  • System Design Questions:
    • Design a system monitoring solution.
    • Implement an alerting and dashboard system.
  • Component: Monitoring System
  • What it Solves:
    • Tracks system health, enables alerting.
  • Caveats/Issues:
    • High overhead, potential noise.
  • Mitigations:
    • Use threshold tuning and anomaly detection.
    • Implement efficient data collection.
    • Use centralized monitoring dashboards.
  • Examples of Tools:
    • Prometheus, Grafana, Datadog

Logging System

  • Use Cases/Problems:
    • Debugging: Captures logs for issue diagnosis.
    • Compliance: Maintains audit trails.
  • System Design Questions:
    • Design a centralized logging system.
    • Implement a scalable logging and analysis solution.
  • Component: Logging System
  • What it Solves:
    • Aids in auditing and troubleshooting.
  • Caveats/Issues:
    • Large data volumes, storage and querying.
  • Mitigations:
    • Use log rotation and retention policies.
    • Implement centralized logging.
    • Optimize log storage and indexing.
  • Examples of Tools:
    • ELK Stack, Splunk, Fluentd

Authentication Service

  • Use Cases/Problems:
    • Secure applications: Manages user identity and access.
    • Single sign-on: Centralizes authentication across services.
  • System Design Questions:
    • Design a secure authentication system.
    • Implement a single sign-on solution.
  • Component: Authentication Service
  • What it Solves:
    • Enhances security, manages user authentication.
  • Caveats/Issues:
    • Single point of failure, security measures needed.
  • Mitigations:
    • Use multi-factor authentication.
    • Implement redundancy and failover.
    • Use secure token storage and management.
  • Examples of Tools:
    • OAuth, Okta, Auth0

Orchestration Tool

  • Use Cases/Problems:
    • Containerized apps: Automates container management.
    • Microservices: Coordinates service deployments.
  • System Design Questions:
    • Design a container orchestration system.
    • Implement a CI/CD pipeline for microservices.
  • Component: Orchestration Tool
  • What it Solves:
    • Automates deployment and management.
  • Caveats/Issues:
    • Adds complexity, learning curve.
  • Mitigations:
    • Use managed orchestration services.
    • Implement robust CI/CD pipelines.
    • Use monitoring and scaling tools.
  • Examples of Tools:
    • Kubernetes, Docker Swarm, Mesos

Configuration Service

  • Use Cases/Problems:
    • Dynamic applications: Centralizes config changes.
    • Large systems: Manages configurations across services.
  • System Design Questions:
    • Design a configuration management system.
    • Implement dynamic configuration updates.
  • Component: Configuration Service
  • What it Solves:
    • Centralizes configuration management.
  • Caveats/Issues:
    • Single point of failure, secure access needed.
  • Mitigations:
    • Use distributed configuration stores.
    • Implement encryption for sensitive data.
    • Use versioning and rollback mechanisms.
  • Examples of Tools:
    • Consul, etcd, Spring Cloud Config

Real-Time Data Aggregation

  • Use Cases/Problems:
    • Real-time dashboards: Aggregates live data feeds.
    • Monitoring: Provides instant insights from data streams.
  • System Design Questions:
    • Design a real-time analytics system.
    • Implement a live data aggregation platform.
  • Component: Real-Time Data Aggregation
  • What it Solves:
    • Enables real-time analytics and monitoring.
  • Caveats/Issues:
    • High complexity, data velocity issues.
  • Mitigations:
    • Use stream processing frameworks.
    • Implement windowing and aggregation techniques.
    • Monitor and scale processing infrastructure.
  • Examples of Tools:
    • Apache Flink, Apache Storm, AWS Kinesis

Distributed Tracing

  • Use Cases/Problems:
    • Microservices: Tracks requests across services.
    • Performance tuning: Identifies bottlenecks and delays.
  • System Design Questions:
    • Design a distributed tracing system.
    • Implement performance monitoring for microservices.
  • Component: Distributed Tracing
  • What it Solves:
    • Aids in debugging and performance monitoring.
  • Caveats/Issues:
    • High overhead, integration required.
  • Mitigations:
    • Use sampling to reduce overhead.
    • Implement efficient trace storage.
    • Use correlation IDs for request tracking.
  • Examples of Tools:
    • Jaeger, Zipkin, OpenTracing

Circuit Breaker

  • Use Cases/Problems:
    • Fault tolerance: Prevents system overloads.
    • Resilient services: Isolates failures in microservices.
  • System Design Questions:
    • Design a fault-tolerant microservices system.
    • Implement circuit breakers for service reliability.
  • Component: Circuit Breaker
  • What it Solves:
    • Protects services from cascading failures.
  • Caveats/Issues:
    • Adds complexity, tuning needed.
  • Mitigations:
    • Use monitoring tools to detect failures.
    • Implement fallback strategies.
    • Use retries and exponential backoff.
  • Examples of Tools:
    • Hystrix, Resilience4j, Istio

Rate Limiter

  • Use Cases/Problems:
    • API management: Protects against request floods.
    • Fair resource allocation: Ensures fair usage policies.
  • System Design Questions:
    • Design an API rate limiting system.
    • Implement a fair resource allocation mechanism.
  • Component: Rate Limiter
  • What it Solves:
    • Controls request rate, prevents abuse.
  • Caveats/Issues:
    • Can impact user experience.
  • Mitigations:
    • Use dynamic rate limiting.
    • Implement user-based quotas.
    • Use monitoring to adjust limits.
  • Examples of Tools:
    • Kong, Envoy, Nginx

Scheduler

  • Use Cases/Problems:
    • Periodic tasks: Automates recurring jobs.
    • Batch processing: Manages large data processing tasks.
  • System Design Questions:
    • Design a job scheduling system.
    • Implement a reliable task processing system.
  • Component: Scheduler
  • What it Solves:
    • Manages background jobs and

tasks.

  • Caveats/Issues:
    • Requires monitoring, can become bottleneck.
  • Mitigations:
    • Use distributed schedulers.
    • Implement job prioritization.
    • Use monitoring and retry mechanisms.
  • Examples of Tools:
    • Apache Airflow, Celery, Kubernetes CronJobs

Service Mesh

  • Use Cases/Problems:
    • Microservices: Handles inter-service communication.
    • Observability: Provides insights into service interactions.
  • System Design Questions:
    • Design a service mesh for microservices.
    • Implement observability for service interactions.
  • Component: Service Mesh
  • What it Solves:
    • Manages microservices communication.
  • Caveats/Issues:
    • Adds operational complexity.
  • Mitigations:
    • Use managed service meshes.
    • Implement automation tools.
    • Use monitoring and observability tools.
  • Examples of Tools:
    • Istio, Linkerd, Consul Connect

Data Backup and Recovery

  • Use Cases/Problems:
    • Disaster recovery: Ensures data is safe and recoverable.
    • Data integrity: Maintains backups for compliance.
  • System Design Questions:
    • Design a backup and recovery system.
    • Implement a reliable disaster recovery solution.
  • Component: Data Backup and Recovery
  • What it Solves:
    • Ensures data durability, protects against data loss.
  • Caveats/Issues:
    • Resource-intensive, regular testing needed. Increases costs. If backups are not up to date there will be data loss. Backup may not be accessible.
  • Mitigations:
    • Use automated backup solutions.
    • Implement multi-region storage.
    • Regularly test backup and recovery processes.
  • Examples of Tools:
    • Use native backup capabilities of the data store, or centralized backup products like AWS Backup, Google Cloud Backup, Veeam

Graph Database

  • Use Cases/Problems:
    • Social networks: Models complex relationships.
    • Recommendation engines: Analyzes connected data.
  • System Design Questions:
    • Design a social network graph database.
    • Implement a recommendation engine.
  • Component: Graph Database
  • What it Solves:
    • Efficiently handles graph-based data and relationships.
  • Caveats/Issues:
    • Steep learning curve, non-graph query inefficiency.
  • Mitigations:
    • Use graph-specific optimizations.
    • Implement hybrid models for different data types.
    • Use indexing and caching for performance.
  • Examples of Tools:
    • Neo4j, Amazon Neptune, OrientDB

Data Lake

  • Use Cases/Problems:
    • Big data analytics: Stores and processes vast data.
    • Data warehousing: Prepares raw data for analytics.
  • System Design Questions:
    • Design a big data analytics platform.
    • Implement a data lake for diverse data types.
  • Component: Data Lake
  • What it Solves:
    • Supports diverse data types and analytics.
  • Caveats/Issues:
    • Governance required, risk of becoming data swamp.
  • Mitigations:
    • Use metadata management.
    • Implement data cataloging.
    • Use data lifecycle policies.
  • Examples of Tools:
    • AWS Lake Formation, Azure Data Lake, Hadoop

Data Streaming Platform

  • Use Cases/Problems:
    • Event-driven architectures: Processes data streams in real-time.
    • Analytics: Real-time insights from continuous data flow.
  • System Design Questions:
    • Design a real-time data streaming system.
    • Implement an event-driven architecture.
  • Component: Data Streaming Platform
  • What it Solves:
    • Facilitates real-time data processing.
  • Caveats/Issues:
    • High operational complexity.
  • Mitigations:
    • Use managed streaming services.
    • Implement scaling strategies.
    • Monitor and optimize processing.
  • Examples of Tools:
    • Apache Kafka, AWS Kinesis, Google Pub/Sub