Day 3 of System Design Case Studies Series
System Design Template…
Welcome back peeps! Hope all’s well.
Note : Please read System Design Important Terms you MUST know before reading this post.
This post will cover the system design template that you can follow along with other details.
Projects Videos —
All the projects, data structures, SQL, algorithms, system design, Data Science and ML , Data Analytics, Data Engineering, , Implemented Data Science and ML projects, Implemented Data Engineering Projects, Implemented Deep Learning Projects, Implemented Machine Learning Ops Projects, Implemented Time Series Analysis and Forecasting Projects, Implemented Applied Machine Learning Projects, Implemented Tensorflow and Keras Projects, Implemented PyTorch Projects, Implemented Scikit Learn Projects, Implemented Big Data Projects, Implemented Cloud Machine Learning Projects, Implemented Neural Networks Projects, Implemented OpenCV Projects,Complete ML Research Papers Summarized, Implemented Data Analytics projects, Implemented Data Visualization Projects, Implemented Data Mining Projects, Implemented Natural Leaning Processing Projects, MLOps and Deep Learning, Applied Machine Learning with Projects Series, PyTorch with Projects Series, Tensorflow and Keras with Projects Series, Scikit Learn Series with Projects, Time Series Analysis and Forecasting with Projects Series, ML System Design Case Studies Series videos will be published on our youtube channel ( just launched).
Subscribe today!
System Design Case Studies — In Depth
Design Instagram
Design Messenger App
Design Twitter
Design URL Shortener
Design Dropbox
Design Youtube
Design API Rate Limiter
Design Web Crawler
Design Facebook’s Newsfeed
Most Popular System Design Questions
Mega Compilation : Solved System Design Case studies
Pre-requisite to this post is Day1 and Day 2 of System Design Case Studies-
Day 1 of System Design Case Studies can be found below-
Day 2 of System Design Case Studies can be found below-
To solve any system design question the rule of thumb is —
Golden rule = Build a framework /template+ Think objectively + Discuss Strategically
In this we will discuss System Design template in detail before taking a deep dive in the case studies -
1. Understand the problem and Define Design Scope
Bottle down to 4 most important features
Use-cases
Who will use the system and how exactly? ( ex- web based/mobile based)
How many users ( approx. estimate) use the system?
2. Capacity Planning and Estimations
Bandwidth estimates
Memory estimates
Traffic estimates
Storage estimates
Latency expectations ( for read-write operations)
Approximate Read/Write Ratio
Throughput requirements
What kind of data and amount of data would you like to store in the cache/disk
3. High Level Design
Consistency vs Availability
Database schema
APIs for Read/Write scenarios for important components
Basic Read/Write scenario
Develop Basic algorithm
4. Deep Dive
Cover following topics in detail ( see links at the end of this post)-
Load Balancers
Message Queues and Task Queues
Reverse Proxy
Architectures ( Microservices)
DataBase [Relational DB vs NoSQL]
DNS
CDN [ Pull vs Push]
Data base Sharding
Caches [ Write through, Write Behind, Refresh Ahead]
Network [ TCP/UDP, REST, RPC]
5. Bottle necks and solutions
Discuss the bottlenecks and tradeoffs
Discuss the other solution approaches
Discuss improvements and performance parameters especially latency and throughput
Justify your choices i.e why you think option 1 is better than option two.
Wrap up- Summarize your design and discussion
Topics you must focus-discuss on —
Real-world performance (relative performance RAM, disk, your network, SSD)
Availability and Reliability (durability, understanding how things can fail)
Datastorage (RAMvs. durablestorage, compression, byte sizes)
Concurrency (threads, deadlock, starvation, consistency, coherence)
Abstraction (understanding how OS, filesystem, and database works)
Performance is a crucial factor in the design of any system. The performance of a system can be measured in terms of its response time, throughput, and scalability.
The following Python code snippet shows how you can measure the response time of a function in Python using the time module:
import timedef my_function():
time.sleep(1) # simulate a long-running operation
return "Hello, world!"start_time = time.time()
result = my_function()
end_time = time.time()response_time = end_time - start_time
print(f"Response time: {response_time:.2f} seconds")The above code measures the time taken by the my_function() function to execute and returns the response time in seconds. By optimizing the performance of your code, you can improve the overall performance of your system.
Availability and Reliability:
Availability and reliability are critical factors in any system. A system should be available 24/7 and should be able to recover quickly from failures. One way to achieve this is by implementing redundancy and fault-tolerance mechanisms. The following Python code snippet shows how you can implement a simple fault-tolerance mechanism in Python using the try-except block:
import requestswhile True:
try:
response = requests.get("https://www.example.com")
if response.status_code == 200:
print("Success")
break
except Exception as e:
print(f"Error: {e}")The above code sends a request to the https://www.example.com URL and retries the request in case of any exception. By implementing such fault-tolerance mechanisms, you can improve the reliability and availability of your system.
Data Storage:
Data storage is an important factor in any system. The choice of data storage depends on various factors such as the size of the data, the frequency of access, and the required durability. The following Python code snippet shows how you can store data in a compressed file using the gzip module:
import gzipdata = b"Hello, world!" * 1000 # simulate a large amount of datawith gzip.open("data.gz", "wb") as f:
f.write(data)The above code compresses the data variable using the gzip module and writes it to a file named data.gz. By compressing your data, you can reduce the amount of storage required and improve the performance of your system.
Concurrency:
Concurrency is an important factor in any system that handles multiple requests simultaneously. Concurrent programming can improve the performance and scalability of your system. However, it can also introduce issues such as deadlocks, starvation, consistency, and coherence. The following Python code snippet shows how you can implement a simple concurrency mechanism using the threading module:
import threadingdef my_function():
print("Starting...")
for i in range(5):
print(f"Task {i}")
print("Finished.")threads = []for i in range(3):
t = threading.Thread(target=my_function)
threads.append(t)
t.start()for t in threads:
t.join()The above code creates three threads and executes the my_function() function concurrently. By implementing concurrency mechanisms, you can improve the performance and scalability of your system.
Abstraction:
Abstraction is an important concept in software engineering. Abstraction allows you to hide the complexity of your system and provide a simplified interface for the users.
Operating System Abstraction:
The os module in Python provides an interface to interact with the operating system. The following code snippet shows how you can use the os module to get the current working directory and list the files in a directory:
import os# Get current working directory
cwd = os.getcwd()
print(f"Current working directory: {cwd}")# List files in a directory
files = os.listdir(".")
print(f"Files in current directory: {files}")File System Abstraction:
The pathlib module in Python provides an object-oriented interface to interact with the file system. The following code snippet shows how you can use the pathlib module to create, read, and delete files:
from pathlib import Path# Create a file
file_path = Path("example.txt")
file_path.touch()# Read a file
with file_path.open() as f:
content = f.read()
print(f"File content: {content}")# Delete a file
file_path.unlink()Database Abstraction:
The sqlite3 module in Python provides an interface to interact with SQLite databases. The following code snippet shows how you can use the sqlite3 module to create a database, create a table, insert data, and retrieve data:
import sqlite3# Create a database
conn = sqlite3.connect("example.db")# Create a table
conn.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")# Insert data
conn.execute("INSERT INTO users (name) VALUES (?)", ("Alice",))
conn.execute("INSERT INTO users (name) VALUES (?)", ("Bob",))# Retrieve data
cursor = conn.execute("SELECT * FROM users")
for row in cursor:
print(row)# Close the connection
conn.close()By using abstraction mechanisms such as the os module, pathlib module, and sqlite3 module, you can simplify the interaction with the operating system, file system, and database and make your code more maintainable and modular.
Let’s elaborate more —
- Bandwidth estimates refer to the amount of data that can be transferred over a network or internet connection in a given period of time.
- Memory estimates refer to the amount of RAM (Random Access Memory) needed for a system or application to function properly.
- Traffic estimates refer to the amount of data that is expected to be sent and received by a system or application.
- Storage estimates refer to the amount of disk space needed for a system or application to function properly.
- Latency expectations for read-write operations refer to the amount of time it takes for a system or application to read or write data.
- Approximate Read/Write Ratio refers to the ratio of read operations to write operations that are expected to be performed by a system or application.
- Throughput requirements refer to the amount of data that a system or application is expected to process in a given period of time.
Bandwidth Estimate:
To estimate the bandwidth of a network or internet connection, you can use the speedtest-cli library in Python. This library performs a speed test and returns the download and upload speeds. Here's a code snippet:
import speedtest# Create a speedtest object
st = speedtest.Speedtest()# Perform the speed test
download_speed = st.download()
upload_speed = st.upload()# Print the results
print(f"Download speed: {download_speed / 1e6:.2f} Mbps")
print(f"Upload speed: {upload_speed / 1e6:.2f} Mbps")Memory Estimate:
To estimate the memory needed for a system or application to function properly, you can use the psutil library in Python. This library provides information about system utilization, including memory usage. Here's a code snippet:
import psutil# Get the memory usage
mem = psutil.virtual_memory()# Print the results
print(f"Total memory: {mem.total / (1024 ** 3):.2f} GB")
print(f"Available memory: {mem.available / (1024 ** 3):.2f} GB")
print(f"Used memory: {mem.used / (1024 ** 3):.2f} GB")Traffic Estimate:
To estimate the traffic that is expected to be sent and received by a system or application, you need to know the expected number of users and the amount of data that each user is expected to send and receive. Here’s a code snippet:
# Set the number of users and the amount of data per user
num_users = 1000
data_per_user = 1e6 # in bytes# Calculate the total traffic
total_traffic = num_users * data_per_user# Print the results
print(f"Total traffic: {total_traffic / (1024 ** 3):.2f} GB")Storage Estimate:
To estimate the storage needed for a system or application to function properly, you need to know the amount of data that the system or application is expected to store. Here’s a code snippet:
# Set the amount of data to be stored
data_to_store = 1e9 # in bytes# Calculate the storage needed
storage_needed = data_to_store / (1024 ** 3)# Print the results
print(f"Storage needed: {storage_needed:.2f} GB")Latency Expectations:
To estimate the latency expectations for read-write operations, you need to know the expected latency for each operation. Here’s a code snippet:
# Set the expected latencies in milliseconds
read_latency = 10
write_latency = 20# Print the results
print(f"Expected read latency: {read_latency} ms")
print(f"Expected write latency: {write_latency} ms")Approximate Read/Write Ratio:
To estimate the approximate read/write ratio, you need to know the expected number of read and write operations. Here’s a code snippet:
# Set the number of read and write operations
num_reads = 10000
num_writes = 1000# Calculate the read/write ratio
read_write_ratio = num_reads / num_writes# Print the results
print(f"Read/write ratio: {read_write_ratio:.2f}")Throughput Requirements:
To estimate the throughput requirements for a system or application, you need to know the amount of data that the system or application is expected to process in a given period of time. Here’s a code snippet:
import time
# Set the amount of data to be processed and the time limit
data_to_process = 1e9 # in bytes
time_limit = 60 # in seconds
# Start the timer
start_time = time.time()
# Stop the timer
end_time = time.time()
# Calculate the throughput
throughput = data_to_process / (end_time - start_time)
# Print the results
print(f"Required throughput: {throughput / (1024 ** 2):.2f} MB/s")In regards to the type of data and amount of data that would be stored in the cache/disk, it would depend on the specific application or system. For example, a database might store large amounts of structured data, while a cache might store frequently accessed data. The amount of data would depend on the storage capacity of the system or application and the expected usage of the data.
- Real-world performance refers to how well a system or application performs in actual use, as opposed to laboratory conditions. It can be affected by factors such as the speed of the RAM, disk, network, and SSD.
- Availability and reliability refer to the ability of a system or application to be available and function correctly. Durability refers to the ability of the data to be stored securely and resist data loss. Understanding how things can fail is important to be able to design a system or application that can handle and recover from failures.
- Data storage refers to the various types of storage available, such as RAM and durable storage. Compression and byte sizes are also important considerations when storing data, as they can affect performance and storage space.
- Concurrency refers to the ability of a system or application to handle multiple operations at the same time. Threads, deadlock, starvation, consistency, and coherence are all important concepts to consider when designing a concurrent system or application.
- Abstraction refers to understanding how various system components work together, such as the operating system, file system, and database. This knowledge is important in designing and implementing a system or application that can effectively make use of the underlying infrastructure.
System Design Template —
Complete System Design Series.
6. Networking, How Browsers work, Content Network Delivery ( CDN)
Github —
Subscribe/ Follow, Like/Clap and Stay Tuned!!
Day 2 : SQL Basics, Query Structure, Built In functions Conditions
Day 4 : Set Theory Operations, Stored Procedures and CASE statements in SQL
Day 6 : Subqueries, Group by, order by and Having clauses in SQL and Analytical Functions
Day 7 : Window Functions, Grouping Sets and Constraints in SQL
Day 8 : BigQuery Basics, SELECT, FROM, WHERE and Date and Extract in BigQuery
Day 9 : Common Expression Table, UNNEST Clause, SQL vs NoSQL Databases
Day 10 : Triggers, Pivot and Cursors in SQL
Day 14 : MySQL in Depth
Day 15 : PostgreSQL inDepth
Anyways, For Day 15 of 15 days of Advanced SQL, we will cover —
PostgreSQL inDepth
Github for Advanced SQL that you can follow —
All the projects, data structures, algorithms, system design, Data Science and ML, Data Engineering, MLOps and Deep Learning videos will be published on our youtube channel ( just launched).
Subscribe today!
System Design Case Studies — In Depth
Complete Data Structures and Algorithm Series
Github —
Some of the other best Series —
30 days of Data Structures and Algorithms and System Design Simplified
Data Science and Machine Learning Research ( papers) Simplified **
100 days : Your Data Science and Machine Learning Degree Series with projects
Complete Data Visualization and Pre-processing Series with projects
Exceptional Github Repos — Part 1
Exceptional Github Repos — Part 2
Tech Newsletter —
If you are interested, you can join my newsletter through which I send tech interview tips, techniques, patterns, hacks — Software Development, ML, Data Science, Startups and Technology projects to more than 30K readers. You can subscribe to Tech Brew :
For Python Projects —
For complete 60 days of Data Science and ML : Day 1 — Day 60 : Quick Recap of 60 days of Data Science and ML
Follow for more updates. Stay tuned and keep coding!
For other projects, tune to —
Build Machine Learning Pipelines( With Code)
Recurrent Neural Network with Keras
Clustering Geolocation Data in Python using DBSCAN and K-Means
Facial Expression Recognition using Keras
Hyperparameter Tuning with Keras Tuner
Custom Layers in Keras
