Top Tweets for #100daysofsystemdesign
Yes, AI is great at coding.
This is the time when it’s important to realize how important system design is.
I’m taking on the challenge of learning system design every day.
No matter how little time I spend on it, consistency matters.
#100DaysOfSystemDesign
I love the idea of CAP Theorem so much in System Design.
𝗗𝗮𝘆 𝟭𝟴 𝗼𝗳 𝟭𝟬𝟬 — 𝗖𝗔𝗣 𝗧𝗵𝗲𝗼𝗿𝗲𝗺: 𝗔𝗣 𝘃𝘀 𝗖𝗣
#100DaysOfSystemDesign
Most people meet CAP Theorem as three letters and a diagram.
But in real systems, CAP only becomes visible when something breaks.
In a distributed system, servers don’t live in the same room. They talk over networks. And networks fail. When that happens, your system is forced to choose how it behaves.
𝗔 𝗖𝗣 𝘀𝘆𝘀𝘁𝗲𝗺 𝗽𝗿𝗶𝗼𝗿𝗶𝘁𝗶𝘇𝗲𝘀 𝗰𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆.
If the system cannot guarantee that everyone sees the same, correct data, it would rather stop responding. It protects correctness, even if users experience downtime.
𝗔 𝗔𝗣 𝘀𝘆𝘀𝘁𝗲𝗺 𝗽𝗿𝗶𝗼𝗿𝗶𝘁𝗶𝘇𝗲𝘀 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆.
It keeps responding to requests even during failures, accepting that some users might see slightly outdated or inconsistent data for a short time.
This is not a technical preference.
It’s a product decision.
Now let’s make it real.
Think of a growing restaurant 🍽️
A CP-style restaurant is cautious. If the order system loses connection to the kitchen, the staff pauses new orders. Customers might be frustrated, but no one gets the wrong meal. Accuracy and trust come first.
An AP-style restaurant keeps serving. Even if the kitchen and front desk are temporarily out of sync, meals still go out. Some orders might arrive late or slightly wrong, but the restaurant stays open and active.
Both restaurants are well-run.
They just optimize for different risks.
Banking apps, payment systems, and inventory platforms often behave like CP systems.
Social media feeds, messaging apps, and content platforms behave more like AP systems.
Good system design is not about eliminating failure.
It’s about deciding how your system fails when failure is unavoidable
𝗱𝗮𝘆 𝟭𝟲 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
As systems grow and data spreads across multiple machines, a new problem appears: you can no longer assume everything is always in sync.
This is where the CAP Theorem comes in.
The CAP Theorem states that in a distributed system, you can only fully guarantee two out of three properties:
Consistency, Availability, and Partition Tolerance.
𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆 means every request sees the same data at the same time.
𝗔𝘃𝗮𝗶𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆 means every request gets a response, even during failures.
𝗣𝗮𝗿𝘁𝗶𝘁𝗶𝗼𝗻 𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝗰𝗲 means the system continues working even when parts of the network can’t communicate.
In real systems, network failures are unavoidable. Once a partition happens, you must choose between staying consistent or staying available.
Now think of a restaurant 🍽️
Imagine a restaurant with multiple branches sharing the same menu and inventory system. If the network goes down between branches, the restaurant must decide: stop taking orders until everything is synced, or keep serving customers even if inventory data may be outdated.
That decision is CAP in action.
CAP is not about what you prefer.
It’s about what you sacrifice when things go wrong.
read the full thing here (https://t.co/b11HdwtQgG)
God bless @TosinOlugbenga Picked up system deisgn coz of him.
𝗱𝗮𝘆 𝟭𝟱 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
At a basic level, SQL and NoSQL are often described as “tables vs documents” or “structured vs flexible.”
But there's more to it
SQL databases are relational systems built around strong consistency, structured schemas, and transactional guarantees. They prioritize correctness and relationships between data.
NoSQL databases are distributed-first systems designed around horizontal scaling, flexible data models, and availability under load. They prioritize performance and scale, sometimes at the cost of strict consistency.
The real difference shows up when systems grow.
SQL systems enforce relationships, constraints, and transactions across data. This makes them ideal when accuracy matters deeply, but harder to scale across many machines.
NoSQL systems relax some of these guarantees to scale easily. They are designed to distribute data across nodes and continue working even during partial failures.
Now think of a restaurant 🍽️
A fine-dining restaurant has strict recipes, precise measurements, and carefully coordinated chefs. Every dish must be correct. That’s SQL.
A fast-food chain focuses on speed, volume, and consistency across locations. Recipes are simpler, and flexibility allows the system to scale globally. That’s NoSQL.
Neither is better. They solve different problems.
System design is about choosing the right tradeoffs.
𝗱𝗮𝘆 𝟭𝟰 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
Before scaling, caching, or load balancing can truly work, one thing must be clear: 𝘄𝗵𝗲𝗿𝗲 𝘆𝗼𝘂𝗿 𝗱𝗮𝘁𝗮 𝗹𝗶𝘃𝗲𝘀 𝗮𝗻𝗱 𝗵𝗼𝘄 𝗶𝘁’𝘀 𝗮𝗰𝗰𝗲𝘀𝘀𝗲𝗱.
At its core, a database is the system’s long-term memory. It is responsible for storing data reliably, retrieving it efficiently, and ensuring it remains correct over time. Every request eventually touches the database, either directly or indirectly.
Databases are designed to answer three fundamental questions:
Can the data be stored safely?
Can it be retrieved quickly?
Can it remain consistent as the system grows?
When databases are poorly designed or misunderstood, systems slow down, errors increase, and scaling becomes painful. Many performance issues blamed on “traffic” are actually data access problems.
Now think of a restaurant 🍽️
The storage room is where all raw ingredients are kept. It must be organized, reliable, and accessible at all times. If ingredients are misplaced, spoiled, or hard to find, the kitchen suffers no matter how skilled the chefs are.
The kitchen doesn’t question whether the storage room exists. It assumes it works. T𝗵𝗮𝘁’𝘀 𝗵𝗼𝘄 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝘁𝗿𝗲𝗮𝘁 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀. 𝗪𝗵𝗲𝗻 𝘁𝗵𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝘀𝘁𝗿𝘂𝗴𝗴𝗹𝗲𝘀, 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗮𝗯𝗼𝘃𝗲 𝗶𝘁 𝗳𝗲𝗲𝗹𝘀 𝗯𝗿𝗼𝗸𝗲𝗻.
𝗦𝘁𝗿𝗼𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝘀𝘁𝗮𝗿𝘁 𝘄𝗶𝘁𝗵 𝘀𝘁𝗿𝗼𝗻𝗴 𝗱𝗮𝘁𝗮 𝗳𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀.
Missed day 13? here you go [https://t.co/dhueBqEHrE]
Tomorrow, we’ll talk about types of databases and when to use each.
![beardedtech_guy's tweet photo. 𝗱𝗮𝘆 𝟭𝟰 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
Before scaling, caching, or load balancing can truly work, one thing must be clear: 𝘄𝗵𝗲𝗿𝗲 𝘆𝗼𝘂𝗿 𝗱𝗮𝘁𝗮 𝗹𝗶𝘃𝗲𝘀 𝗮𝗻𝗱 𝗵𝗼𝘄 𝗶𝘁’𝘀 𝗮𝗰𝗰𝗲𝘀𝘀𝗲𝗱.
At its core, a database is the system’s long-term memory. It is responsible for storing data reliably, retrieving it efficiently, and ensuring it remains correct over time. Every request eventually touches the database, either directly or indirectly.
Databases are designed to answer three fundamental questions:
Can the data be stored safely?
Can it be retrieved quickly?
Can it remain consistent as the system grows?
When databases are poorly designed or misunderstood, systems slow down, errors increase, and scaling becomes painful. Many performance issues blamed on “traffic” are actually data access problems.
Now think of a restaurant 🍽️
The storage room is where all raw ingredients are kept. It must be organized, reliable, and accessible at all times. If ingredients are misplaced, spoiled, or hard to find, the kitchen suffers no matter how skilled the chefs are.
The kitchen doesn’t question whether the storage room exists. It assumes it works. T𝗵𝗮𝘁’𝘀 𝗵𝗼𝘄 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝘁𝗿𝗲𝗮𝘁 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀. 𝗪𝗵𝗲𝗻 𝘁𝗵𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝘀𝘁𝗿𝘂𝗴𝗴𝗹𝗲𝘀, 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗮𝗯𝗼𝘃𝗲 𝗶𝘁 𝗳𝗲𝗲𝗹𝘀 𝗯𝗿𝗼𝗸𝗲𝗻.
𝗦𝘁𝗿𝗼𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝘀𝘁𝗮𝗿𝘁 𝘄𝗶𝘁𝗵 𝘀𝘁𝗿𝗼𝗻𝗴 𝗱𝗮𝘁𝗮 𝗳𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀.
Missed day 13? here you go [https://t.co/dhueBqEHrE]
Tomorrow, we’ll talk about types of databases and when to use each.](https://pbs.twimg.com/media/G_x09AZWIAAnp3I.png)
𝗱𝗮𝘆 𝟭𝟯 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
Caching makes systems faster, but caching alone is not enough.
Once data is cached, the real problem becomes how long that data should be trusted.
When an application serves data from cache, it is serving a snapshot in time. If the original data changes and the cache is not updated, users begin to see stale information. This is why caching always comes with two important concepts: expiration and invalidation.
𝗖𝗮𝗰𝗵𝗲 𝗲𝘅𝗽𝗶𝗿𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝘁𝗶𝗺𝗲 𝗯𝗮𝘀𝗲𝗱. Data is stored for a defined period and automatically removed after that time passes.
This approach is simple and works well when data does not change often or when slight delays in freshness are acceptable.
𝗖𝗮𝗰𝗵𝗲 𝗶𝗻𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝗲𝘃𝗲𝗻𝘁 𝗯𝗮𝘀𝗲𝗱. When the source data changes, the cache is immediately cleared or updated.
This is necessary for systems where correctness matters, such as payments, sessions, inventory, or user profiles.
𝗡𝗼𝘄 𝘁𝗵𝗶𝗻𝗸 𝗼𝗳 𝗮 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️
Some items in the kitchen are prepared once and trusted for the entire day. They are refreshed on a schedule, not every time someone orders. That’s cache expiration.
But if an ingredient suddenly goes bad or runs out, the kitchen stops using it immediately. Waiting until closing time would cause serious problems. That’s cache invalidation.
Fast systems are easy to build.
Correct and fast systems are designed.
Missed day 12? here you go [https://t.co/Du9ZU9GZ0b]
Inspired by @TosinOlugbenga and my bro @gozkybrain4u
![beardedtech_guy's tweet photo. 𝗱𝗮𝘆 𝟭𝟯 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
Caching makes systems faster, but caching alone is not enough.
Once data is cached, the real problem becomes how long that data should be trusted.
When an application serves data from cache, it is serving a snapshot in time. If the original data changes and the cache is not updated, users begin to see stale information. This is why caching always comes with two important concepts: expiration and invalidation.
𝗖𝗮𝗰𝗵𝗲 𝗲𝘅𝗽𝗶𝗿𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝘁𝗶𝗺𝗲 𝗯𝗮𝘀𝗲𝗱. Data is stored for a defined period and automatically removed after that time passes.
This approach is simple and works well when data does not change often or when slight delays in freshness are acceptable.
𝗖𝗮𝗰𝗵𝗲 𝗶𝗻𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝗲𝘃𝗲𝗻𝘁 𝗯𝗮𝘀𝗲𝗱. When the source data changes, the cache is immediately cleared or updated.
This is necessary for systems where correctness matters, such as payments, sessions, inventory, or user profiles.
𝗡𝗼𝘄 𝘁𝗵𝗶𝗻𝗸 𝗼𝗳 𝗮 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️
Some items in the kitchen are prepared once and trusted for the entire day. They are refreshed on a schedule, not every time someone orders. That’s cache expiration.
But if an ingredient suddenly goes bad or runs out, the kitchen stops using it immediately. Waiting until closing time would cause serious problems. That’s cache invalidation.
Fast systems are easy to build.
Correct and fast systems are designed.
Missed day 12? here you go [https://t.co/Du9ZU9GZ0b]
Inspired by @TosinOlugbenga and my bro @gozkybrain4u](https://pbs.twimg.com/media/G_r2dYVWEAEV0KW.jpg)
Day 11: Caching Basics
#100DaysOfSystemDesign
As systems scale, not every request should hit the database.
Some data is requested repeatedly, and recomputing or refetching it every time wastes time and resources.
This is where caching comes in.
Caching is the practice of storing frequently accessed data closer to where it’s needed, so future requests can be served faster.
Think of a restaurant.
Instead of cooking every dish from scratch each time, the kitchen preps popular ingredients in advance.
When an order comes in, the meal is ready much faster.
Caching reduces response time, lowers load on databases, and improves system throughput.
But caching comes with trade offs.
Data can become stale, and deciding what to cache and when to refresh it matters.
Caching is not about speed alone.
It’s about using resources intelligently.
Tomorrow, we’ll talk about where caches live and common caching patterns.
𝗗𝗮𝘆 𝟭𝟬: 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝗶𝗲𝘀
#100DaysOfSystemDesign
Yesterday, we i𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝗱 𝗹𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴 and why it’s essential once systems scale horizontally.
Today, let’s talk about how load balancers decide where traffic goes.
Load balancing strategies are the rules used to distribute incoming requests across multiple servers. The goal is to keep the system fast, fair, and resilient under load.
There are three commonly used strategies.
𝗥𝗼𝘂𝗻𝗱 𝗥𝗼𝗯𝗶𝗻 sends requests to servers one after the other, assuming all servers are equally capable.
𝗟𝗲𝗮𝘀𝘁 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 routes traffic to the server currently handling the fewest active requests.
𝗛𝗮𝘀𝗵 𝗕𝗮𝘀𝗲𝗱 𝗥𝗼𝘂𝘁𝗶𝗻𝗴 consistently sends similar requests to the same server, often based on user or request attributes.
Now, think of a restaurant.
𝗥𝗼𝘂𝗻𝗱 𝗥𝗼𝗯𝗶𝗻 𝗶𝘀 𝗹𝗶𝗸𝗲 𝘀𝗲𝗮𝘁𝗶𝗻𝗴 𝗴𝘂𝗲𝘀𝘁𝘀 𝗲𝘃𝗲𝗻𝗹𝘆 𝗮𝗰𝗿𝗼𝘀𝘀 𝗮𝗹𝗹 𝘄𝗮𝗶𝘁𝗲𝗿𝘀, 𝗼𝗻𝗲 𝗯𝘆 𝗼𝗻𝗲, 𝘄𝗵𝗲𝗻 𝗲𝘃𝗲𝗿𝘆𝗼𝗻𝗲 𝗶𝘀 𝗲𝗾𝘂𝗮𝗹𝗹𝘆 𝗳𝗿𝗲𝗲.
𝗟𝗲𝗮𝘀𝘁 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗶𝘀 𝗹𝗶𝗸𝗲 𝘀𝗲𝗻𝗱𝗶𝗻𝗴 𝗴𝘂𝗲𝘀𝘁𝘀 𝘁𝗼 𝘁𝗵𝗲 𝘄𝗮𝗶𝘁𝗲𝗿 𝘄𝗵𝗼 𝗶𝘀 𝗰𝘂𝗿𝗿𝗲𝗻𝘁𝗹𝘆 𝗹𝗲𝗮𝘀𝘁 𝗯𝘂𝘀𝘆 𝗱𝘂𝗿𝗶𝗻𝗴 𝗽𝗲𝗮𝗸 𝗵𝗼𝘂𝗿𝘀.
𝗛𝗮𝘀𝗵 𝗯𝗮𝘀𝗲𝗱 𝗿𝗼𝘂𝘁𝗶𝗻𝗴 𝗶𝘀 𝗹𝗶𝗸𝗲 𝗮𝘀𝘀𝗶𝗴𝗻𝗶𝗻𝗴 𝗿𝗲𝗴𝘂𝗹𝗮𝗿 𝗰𝘂𝘀𝘁𝗼𝗺𝗲𝗿𝘀 𝘁𝗼 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘄𝗮𝗶𝘁𝗲𝗿 𝗲𝘃𝗲𝗿𝘆 𝘁𝗶𝗺𝗲 𝗯𝗲𝗰𝗮𝘂𝘀𝗲 𝘁𝗵𝗮𝘁 𝘄𝗮𝗶𝘁𝗲𝗿 𝗸𝗻𝗼𝘄𝘀 𝘁𝗵𝗲𝗶𝗿 𝗽𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀.
Each strategy solves a different problem.
Choosing the wrong one can create bottlenecks even with many servers.
Tomorrow, we’ll look at where load balancers sit in real system architectures.
𝗗𝗮𝘆 𝟵: 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴
#100DaysOfSystemDesign
So far, we’ve talked about scaling vertically and horizontally, and why stateless systems make scaling easier.
But there’s a missing question:
When you have multiple servers,
how do incoming requests know where to go?
𝗧𝗵𝗮𝘁’𝘀 𝘁𝗵𝗲 𝗿𝗼𝗹𝗲 𝗼𝗳 𝗮 𝗹𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝗿.
A load balancer sits in front of your servers and distributes incoming traffic so no single machine is overwhelmed while others sit idle.
Instead of users hitting servers directly, they hit the load balancer, which decides where each request should be routed.
This improves availability, prevents hotspots, and makes the system more resilient to failures.
Think of a restaurant again.
Customers don’t walk into the kitchen and pick a chef.
They speak to the host at the entrance.
The host checks which tables or waiters are free and assigns customers accordingly.
That host is the load balancer.
If one waiter is overloaded or unavailable, customers are redirected to others without noticing any issue.
Load balancing works best with stateless services.
Since no server holds user specific information, any request can safely go to any instance.
Without load balancing, horizontal scaling loses most of its value.
Tomorrow, we’ll talk about different load balancing strategies and when to use each.
Missed Lesson 1 - 7 Recap? Here you go [https://t.co/LyneITrp7Z]
![beardedtech_guy's tweet photo. 𝗗𝗮𝘆 𝟵: 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴
#100DaysOfSystemDesign
So far, we’ve talked about scaling vertically and horizontally, and why stateless systems make scaling easier.
But there’s a missing question:
When you have multiple servers,
how do incoming requests know where to go?
𝗧𝗵𝗮𝘁’𝘀 𝘁𝗵𝗲 𝗿𝗼𝗹𝗲 𝗼𝗳 𝗮 𝗹𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝗿.
A load balancer sits in front of your servers and distributes incoming traffic so no single machine is overwhelmed while others sit idle.
Instead of users hitting servers directly, they hit the load balancer, which decides where each request should be routed.
This improves availability, prevents hotspots, and makes the system more resilient to failures.
Think of a restaurant again.
Customers don’t walk into the kitchen and pick a chef.
They speak to the host at the entrance.
The host checks which tables or waiters are free and assigns customers accordingly.
That host is the load balancer.
If one waiter is overloaded or unavailable, customers are redirected to others without noticing any issue.
Load balancing works best with stateless services.
Since no server holds user specific information, any request can safely go to any instance.
Without load balancing, horizontal scaling loses most of its value.
Tomorrow, we’ll talk about different load balancing strategies and when to use each.
Missed Lesson 1 - 7 Recap? Here you go [https://t.co/LyneITrp7Z]](https://pbs.twimg.com/media/G_X0boXXUAACyo9.jpg)
Day 8 #100DaysOfSystemDesign Recap (Lesson 1 to 7)
The last 7 days have been about building a solid mental model for system design, starting from fundamentals and gradually layering complexity.
𝗗𝗮𝘆 𝟭: 𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝘁𝗼 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻
What system design really means, how to think in systems, and why it goes beyond diagrams and tools.
https://t.co/NPe8n2AtpJ
𝗗𝗮𝘆 𝟮: 𝗪𝗵𝘆 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 𝗠𝗮𝘁𝘁𝗲𝗿𝘀
A bird’s eye view of why scalable, reliable systems are intentional, not accidental.
https://t.co/UZAFgfmZYV
𝗗𝗮𝘆 𝟯: 𝗧𝘆𝗽𝗲𝘀 𝗼𝗳 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 (𝗛𝗟𝗗 & 𝗟𝗟𝗗)
Understanding the difference between high level architecture and low level implementation decisions.
https://t.co/yRGW8gjazD
𝗗𝗮𝘆 𝟰: 𝗦𝗰𝗮𝗹𝗶𝗻𝗴 𝗕𝗮𝘀𝗶𝗰𝘀
What scaling really means, when systems break, and why foresight matters before growth hits.
https://t.co/U134eUoSoJ
𝗗𝗮𝘆 𝟱: 𝗩𝗲𝗿𝘁𝗶𝗰𝗮𝗹 𝗦𝗰𝗮𝗹𝗶𝗻𝗴
Making a single machine stronger, how CPU and RAM affect performance, and why this approach has limits.
https://t.co/LL6IdjsUGx
𝗗𝗮𝘆 𝟲: 𝗛𝗼𝗿𝗶𝘇𝗼𝗻𝘁𝗮𝗹 𝗦𝗰𝗮𝗹𝗶𝗻𝗴
Adding more machines, distributing load, and why this changes how systems are designed.
https://t.co/69AAmMkByc
𝗗𝗮𝘆 𝟳: 𝗦𝘁𝗮𝘁𝗲𝗹𝗲𝘀𝘀 𝘃𝘀 𝗦𝘁𝗮𝘁𝗲𝗳𝘂𝗹 𝗦𝘆𝘀𝘁𝗲𝗺𝘀
How systems manage user data, why stateless systems scale better, and where state still matters.
https://t.co/nNePxDGAUx
Week 1 focused on foundations.
Week 2 goes deeper into real world trade offs.
Thanks to everyone engaging so far, real mvps.
Inspired by my chief director @TosinOlugbenga and my bro @gozkybrain4u
Day 6: Horizontal Scaling
#100DaysOfSystemDesign
Yesterday, we talked about vertical scaling and how far you can go by making a single machine stronger.
Today, let’s talk about horizontal scaling.
Horizontal scaling means increasing capacity by adding more machines instead of upgrading one.
Rather than strengthening a single server, you distribute the load across multiple servers.
How does this affect performance?
Requests are shared across machines, usually through a load balancer.
This prevents any single server from becoming overwhelmed and improves reliability.
In horizontal scaling, each server handles a portion of the traffic.
If traffic increases, you add more servers.
If traffic drops, you remove some.
Think of it like a restaurant:
Instead of expanding one kitchen endlessly, the restaurant opens multiple branches.
Customers are routed to the nearest or least busy branch.
Each branch represents a server.
The system directing customers represents the load balancer.
If one branch shuts down, others keep serving customers.
That’s fault tolerance.
Horizontal scaling shines when:
• one machine has hit its limit
• high availability is required
• growth is unpredictable
But it comes with tradeoffs.
You must think about state, data consistency, and coordination between machines.
Horizontal scaling works best when systems are designed for it from the start.
Tomorrow, we’ll talk about stateless vs stateful systems and why they matter for scaling.
Inspired by @TosinOlugbenga
Excited to have @khushiepal joining me tomorrow as my learning + helping buddy to tackle the next phase! 👩💻👨💻
Blog: https://t.co/BBnbWASxk2
#BuildInPublic #100DaysOfSystemDesign #LearnInPublic #DevTool #MongoDB #WebScraping #Python
𝗱𝗮𝘆 𝟰 𝗼𝗳 𝟭𝟬𝟬
Scaling Basics
#100DaysOfSystemDesign
Now that we understand how systems are designed, let’s talk about scaling.
𝗦𝗰𝗮𝗹𝗶𝗻𝗴 𝗶𝘀 𝗮𝗯𝗼𝘂𝘁 𝗽𝗿𝗲𝗽𝗮𝗿𝗶𝗻𝗴 𝗳𝗼𝗿 𝗴𝗿𝗼𝘄𝘁𝗵. It answers a simple question: how does a system continue to work as demand increases?
No system stays small forever. As more users arrive, requests increase and data grows, yet the system is still expected to deliver the same level of reliability and performance.
Scaling is not about fixing broken systems. It’s about ensuring that success doesn’t overwhelm what you’ve built.
𝗡𝗼𝘄, 𝗯𝗮𝗰𝗸 𝘁𝗼 𝗼𝘂𝗿 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️
As the restaurant becomes more popular, customer numbers increase steadily. Instead of reacting to pressure, the owners plan ahead.
They hire more cooks, expand the kitchen, and open new outlets in busy areas. Service remains smooth, not because demand stayed small, but because the system was designed to grow.
𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝘀𝗰𝗮𝗹𝗲 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘄𝗮𝘆.
Scaling is a design choice, not an emergency response.
Missed Day 3?
Here you go 👉 [https://t.co/yRGW8gjazD]
Read the full piece on my linkedin : https://t.co/7uojDUxJB3
Tomorrow: Vertical vs Horizontal Scaling 🚀
Join #100DaysOfCode
Inspired by @TosinOlugbenga @gozkybrain4u
System Design course coming soon.
![beardedtech_guy's tweet photo. 𝗱𝗮𝘆 𝟰 𝗼𝗳 𝟭𝟬𝟬
Scaling Basics
#100DaysOfSystemDesign
Now that we understand how systems are designed, let’s talk about scaling.
𝗦𝗰𝗮𝗹𝗶𝗻𝗴 𝗶𝘀 𝗮𝗯𝗼𝘂𝘁 𝗽𝗿𝗲𝗽𝗮𝗿𝗶𝗻𝗴 𝗳𝗼𝗿 𝗴𝗿𝗼𝘄𝘁𝗵. It answers a simple question: how does a system continue to work as demand increases?
No system stays small forever. As more users arrive, requests increase and data grows, yet the system is still expected to deliver the same level of reliability and performance.
Scaling is not about fixing broken systems. It’s about ensuring that success doesn’t overwhelm what you’ve built.
𝗡𝗼𝘄, 𝗯𝗮𝗰𝗸 𝘁𝗼 𝗼𝘂𝗿 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️
As the restaurant becomes more popular, customer numbers increase steadily. Instead of reacting to pressure, the owners plan ahead.
They hire more cooks, expand the kitchen, and open new outlets in busy areas. Service remains smooth, not because demand stayed small, but because the system was designed to grow.
𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝘀𝗰𝗮𝗹𝗲 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘄𝗮𝘆.
Scaling is a design choice, not an emergency response.
Missed Day 3?
Here you go 👉 [https://t.co/yRGW8gjazD]
Read the full piece on my linkedin : https://t.co/7uojDUxJB3
Tomorrow: Vertical vs Horizontal Scaling 🚀
Join #100DaysOfCode
Inspired by @TosinOlugbenga @gozkybrain4u
System Design course coming soon.](https://pbs.twimg.com/media/G-93ISaXQAEztjP.jpg)
𝗗𝗮𝘆 𝟯 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
Now that we understand why system design matters, let’s look at the two main ways it is approached.
𝗧𝘆𝗽𝗲𝘀 𝗼𝗳 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻
There are two key levels: High-Level Design (HLD) and Low-Level Design (LLD).
High-Level Design (HLD) focuses on the big picture. It defines how major components interact, how data flows, how traffic is handled, and how the system grows without breaking.
Low-Level Design (LLD) focuses on the details. It defines how individual components work internally, how requests are processed, how data is stored, and how logic is executed.
𝗕𝗮𝗰𝗸 𝘁𝗼 𝗼𝘂𝗿 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️
HLD is deciding how many kitchens you need, how many tables fit the space, and which staff handles dine-in versus delivery. It’s planning for success before the first customer walks in.
LLD is deciding how each chef prepares a meal, the exact steps they follow, the tools they use, and how food moves from the kitchen to the table during a busy hour.
𝗛𝗟𝗗 𝗲𝗻𝘀𝘂𝗿𝗲𝘀 𝘁𝗵𝗲 𝘀𝘆𝘀𝘁𝗲𝗺 𝗰𝗮𝗻 𝗴𝗿𝗼𝘄.
𝗟𝗟𝗗 𝗲𝗻𝘀𝘂𝗿𝗲𝘀 𝘁𝗵𝗲 𝘀𝘆𝘀𝘁𝗲𝗺 𝘄𝗼𝗿𝗸𝘀.𝗚𝗼𝗼𝗱 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝘀 𝗯𝗼𝘁𝗵.
Read and follow me on linkedin https://t.co/OTSUmJkWQx
Tomorrow: Scaling basics 🚀
Missed day 2? here you go https://t.co/UZAFgfms9n
Inspired by @TosinOlugbenga
𝗱𝗮𝘆 𝟮 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
We have successfuly established the meaning of system design so lets look into why.
𝗪𝗵𝘆 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 𝗺𝗮𝘁𝘁𝗲𝗿𝘀
No system stays small forever. Growth exposes hidden problems.
𝗧𝗵𝗶𝗻𝗸 𝗼𝗳 𝘁𝗵𝗮𝘁 𝘀𝗮𝗺𝗲 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 𝗳𝗿𝗼𝗺 𝗱𝗮𝘆 𝟭 🍽️
At first, it has one cook and a few customers. Orders are easy, food goes out on time, everyone is happy.
As the restaurant becomes popular, more customers arrive, orders pile up, and the kitchen starts to feel tight. Mistakes happen, some tables wait too long, and a few customers leave. 𝗡𝗼𝘁 𝗯𝗲𝗰𝗮𝘂𝘀𝗲 𝘁𝗵𝗲 𝗰𝗼𝗼𝗸 𝗶𝘀𝗻’𝘁 𝘀𝗸𝗶𝗹𝗹𝗲𝗱, 𝗯𝘂𝘁 𝗯𝗲𝗰𝗮𝘂𝘀𝗲 𝘁𝗵𝗲 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 𝘄𝗮𝘀𝗻’𝘁 𝗱𝗲𝘀𝗶𝗴𝗻𝗲𝗱 𝘁𝗼 𝗵𝗮𝗻𝗱𝗹𝗲 𝗴𝗿𝗼𝘄𝘁𝗵.
Now imagine the restaurant decides to offer delivery without reorganizing the kitchen or adding staff. Orders get mixed up, the cook is stretched thin, and both dine-in and delivery customers are waiting. Chaos slowly creeps in, even if everyone is trying their best.
This is exactly what happens in applications. When apps grow, add features, or get more users without planning, things slow down, break, and frustrate users. 𝗬𝗼𝘂𝗿 𝗰𝗼𝗱𝗲 𝗰𝗮𝗻 𝗯𝗲 𝗳𝗶𝗻𝗲, everyone can be doing their best, and the system can still fail.
Be that engineer that prioritizes system thinking and design!
Read the full piece here : https://t.co/5FXenzJhsQ
Missed day 1 ? Here you go https://t.co/NPe8n2zVAb
Inspired by @TosinOlugbenga
Join #100DaysOfCode by @gozkybrain4u my bro 🔥
𝗗𝗮𝘆 𝟭 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign
While AI is doing the heavy lifting, let's take a step forward in understanding how systems actually work.
So I’ve been learning system design for a while now, and I'd be sharing the little I know in 100days on LinkedIn and X.
https://t.co/KMVC4vht7y
𝗪𝗵𝗮𝘁 𝗶𝘀 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻?
System design is the process of planning how different parts of an application work together to deliver value.
𝗧𝗵𝗶𝗻𝗸 𝗼𝗳 𝗮 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️
𝘈 𝘤𝘶𝘴𝘵𝘰𝘮𝘦𝘳 𝘱𝘭𝘢𝘤𝘦𝘴 𝘢𝘯 𝘰𝘳𝘥𝘦𝘳, 𝘵𝘩𝘦 𝘬𝘪𝘵𝘤𝘩𝘦𝘯 𝘱𝘳𝘦𝘱𝘢𝘳𝘦𝘴 𝘪𝘵, 𝘢𝘯𝘥 𝘵𝘩𝘦 𝘸𝘢𝘪𝘵𝘦𝘳 𝘥𝘦𝘭𝘪𝘷𝘦𝘳𝘴 𝘪𝘵.
𝘐𝘧 𝘵𝘩𝘪𝘴 𝘧𝘭𝘰𝘸 𝘪𝘴𝘯’𝘵 𝘸𝘦𝘭𝘭 𝘱𝘭𝘢𝘯𝘯𝘦𝘥, 𝘰𝘳𝘥𝘦𝘳𝘴 𝘨𝘦𝘵 𝘮𝘪𝘹𝘦𝘥 𝘶𝘱 𝘢𝘯𝘥 𝘤𝘶𝘴𝘵𝘰𝘮𝘦𝘳𝘴 𝘨𝘦𝘵 𝘧𝘳𝘶𝘴𝘵𝘳𝘢𝘵𝘦𝘥.
𝗧𝗵𝗮𝘁 𝗽𝗹𝗮𝗻𝗻𝗶𝗻𝗴 𝗼𝗳 𝘄𝗵𝗼 𝗱𝗼𝗲𝘀 𝘄𝗵𝗮𝘁 𝗮𝗻𝗱 𝗵𝗼𝘄 𝗶𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻 𝗳𝗹𝗼𝘄𝘀 𝗶𝘀 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻.
It’s important because a well designed system saves time, scales better, and avoids chaos.
Inspired by @TosinOlugbenga
Join #100DaysOfCode with @gozkybrain4u too 🔥
What I would love, though, is your feedback:
1. Ideas
2. Opinions
3. Even roasts (those help the most)
With that, Week 1 is a wrap. Signing off for today—see you again tomorrow.
#BuildInPublic #100DaysOfSystemDesign #LearnInPublic #DevTool
Day 7/100 ✅ #100DaysOfSystemDesign
Database locked in: MongoDB Atlas M0
LLM running: Phi-3 Mini (2.2GB) ✅
Reality check: DeepSeek V3's 400GB → Phi-3's 2.2GB
Test passed: Amazon SDE II job → clean JSON
Key insight: Best tech = tech that ships
Day 6/100 ✅ #100DaysOfSystemDesign
3hr planning session → HuntKit architecture LOCKED ✅ 250+ company career pages mapped
✅ $0 LLM costs (DeepSeek V3 local)
✅ Hashing skips 95% re-processing
Flow: Scrape → Hash → LLM → Postgres → API
Smart: Only process page changes
Day 5/100 ✅ #100DaysOfSystemDesign
Legal deep dive: Career pages LOWER risk than aggregators
• Public data companies WANT you to see
• Legit purpose (help job seekers)
• No competitive harm
Last Seen Hashtags on Sotwe
kaw
Seen from Peru
PostApocalyptic
Seen from Brazil
omnia
Seen from United States
gachagay video
Seen from Mexico
brondong
Seen from Singapore
Toon
Seen from Germany
نيج_عراقي
Seen from Netherlands
CervezaGuayacan
Seen from United States
yahudiDölü
Seen from Portugal
anindianaffair
Seen from Ecuador
Most Popular Users
Elon Musk 
@elonmusk
240.1M followers
Barack Obama
@barackobama
119.3M followers
Donald J. Trump
@realdonaldtrump
111.6M followers
Cristiano Ronaldo
@cristiano
108.8M followers
Narendra Modi
@narendramodi
106.9M followers
Rihanna
@rihanna
97.2M followers
NASA
@nasa
92.1M followers
Justin Bieber
@justinbieber
90.5M followers
KATY PERRY
@katyperry
86.7M followers
Taylor Swift
@taylorswift13
80.5M followers
Lady Gaga
@ladygaga
72.1M followers
Kim Kardashian
@kimkardashian
69.3M followers
YouTube
@youtube
68.6M followers
Virat Kohli
@imvkohli
68.4M followers
Bill Gates
@billgates
63.4M followers
The Ellen Show
@theellenshow
62.5M followers
CNN
@cnn
61.9M followers
Neymar Jr
@neymarjr
60.9M followers
X
@x
60.9M followers
CNN Breaking News
@cnnbrk
59.9M followers