From 5 Users to 1 Million 🚀 How Systems Scale (Step-by-Step)

Added: 2026-05-06

[00:00:00]latency zero. Have you ever wondered why your website work perfectly with the five user, but suddenly crashes when the thousand or 10,000 user comes up?

[00:00:10]So, today we are going to understand how to build a system that a scale from few users to the thousand to the millions without breaking.

[00:00:20]Let Let's understand this a step by a step.

[00:00:28]Suppose this is you and you have built a website.

[00:00:34]This is your website.

[00:00:38]Now on the day one you notice that only the five user have been visited to your website.

[00:00:51]Only the five user have been visited.

[00:00:53]Now you notice that everything work perfectly.

[00:00:57]Uh request and response is very fast. No error and user find very a smooth experience. Now on the day two let's say 10k user have been visited to your website.

[00:01:14]Now your website become slow.

[00:01:19]Request start falling.

[00:01:24]And user start leaving your website because user find very bad experience uh from your website.

[00:01:38]So, what went wrong?

[00:01:40]Let's break it down.

[00:01:54]Before we fix this problem, we need to understand the basic thing. First one is the request.

[00:02:00]So, request is like this is the user and this is the server.

[00:02:09]So, when the user ask something from the server, simply this is called request.

[00:02:16]So, if I take it one example, so let's say if you open the Instagram and user send request to the server and the server send that data back.

[00:02:27]Now the server server is simply just a machine that process request and send response.

[00:02:33]Uh talking about the scaling, so a scaling means handling more user without slowing down or crashing.

[00:02:41]So, this is the simply meaning of the scaling.

[00:02:51]Now let's see how system evolve a step by a step. So, for that we will divide into the multiple steps starting from based on the number of user. So, at a start at a starting we are taking only the 100 user.

[00:03:06]So, let's say we are taking only the 100 users.

[00:03:11]Now in the beginning everything run on a single machine.

[00:03:17]So, basically we have the monolith structure.

[00:03:21]We have only the single machine.

[00:03:22]Everything will run on the single machine. Your back end back end we have no JS Django rails whatever back end will run on the single machine.

[00:03:33]Database and the server all are inside one system.

[00:03:39]So, if I take one example, let's say you have created a small blog website. So, what you usually do? You keep all the things into the single server.

[00:03:50]Because the number of user is very less.

[00:04:07]Now the coming to the bottleneck.

[00:04:10]So, as the number of user have been increased let's say we are increasing the number of user.

[00:04:17]So, your system start a struggling. CPU become busy and the memory get full. Database become slow.

[00:04:41]So, the So, the thing is that how do we fix this?

[00:04:46]So, we come to the step a stage two.

[00:04:50]So uh in the stage two we basically taking 100 to 1k users.

[00:05:01]Now we separate the database from the main server.

[00:05:06]So, this this is the this is the app server.

[00:05:12]And this is the database server.

[00:05:19]So, app server will handle the logic and database server will handle the data.

[00:05:29]Okay, so if I take one example, so let's say you are trying to login. So, login system basically login system at the start at the starting app server will handle like it check the logic and DB store the users data.

[00:05:57]Now we are increasing the number of user from 1k to the 5k.

[00:06:04]So you can see that we are increasing the number of user gradually starting from the 100 to the thousand now five 5,000 then we will increase number of 10,000 then millions billions.

[00:06:22]So So, at the stage three So, what we can do? We can add the multiple server here.

[00:06:37]So, let's say this is the server one, this is server two, this is server three.

[00:06:43]Right?

[00:06:44]And uh But the thing is that how we can distribute the traffic? Let's say this is the user and uh user want to get response. But the But the question is that how uh how the how we can get to know that the request goes to the particular server. So, the load balancer comes into the picture and load balancer basically take a request and it redirect to the multiple server based on the availability of the server.

[00:07:16]So, like we have the L4 L7 type of load balancer. We will We will discuss this into the upcoming lecture.

[00:07:24]Now using a load balancer uh like we are using the load balancer, so it will distribute the traffic to the multiple server.

[00:07:36]Now the traffic is distributed and the system become faster and reliable.

[00:07:51]So the question is that why we are using the load balancer?

[00:07:58]Thing is that we want high availability so that so that it uh eliminate the single point of failure. If app server uh like let's say we have the multiple server and this is the load balancer we have.

[00:08:19]This is server one, server two, and server server one is get crashed. So, load balancer redirect the request to the server two or server three based on the availability.

[00:08:31]Now uh it provide the infinite horizontal scaling. So, let's say uh in we have the server one, server two, and the server three. We can add more server here. Let's the server four, server five.

[00:08:49]So, load balancer basically uh like it provide the idea or it give the give the condition uh so that we can increase the we can do the infinite horizontal scaling here.

[00:09:14]Now we are increasing the number of user from 5k to 10k.

[00:09:22]So, this is the stage four.

[00:09:24]Previous So, starting from the stage one, stage two, stage three, stage four, we we have come to the final stage where we have increased the number of user. Now the thing is that uh we can add the caching here.

[00:09:43]Because the database is still getting too many requests and so we have introduced cache here. So, cache basically store the frequent use data in the fast memory.

[00:09:54]For example, let's say you open the Instagram. So this is your Instagram and uh let's say at the first time user profile get a store like at the first time user this is the user.

[00:10:09]So user profile this is stored into the DB.

[00:10:12]And at the second time it basically uh it basically get the user profile from the cache.

[00:10:22]Instead of calling or instead of getting the data from the DB uh it directly get it from the cache.

[00:10:35]Because the cache is faster so >> [snorts] >> Now we can add the CDN here also.

[00:10:58]CDN that is the content delivery network. So we have multiple type of CDN. For example CloudFlare or Akamai.

[00:11:07]So these are basically provide CDN facility. So the let's say we have the images in our website, videos or a static content to serve that that we can use the CDN.

[00:11:20]So let's say we have the videos.

[00:11:26]images or a static content To serve all those we can use the CDN.

[00:11:40]Like CDN CDN delivers content from the nearest server.

[00:11:45]And for example let's say we are taking example of YouTube or Netflix so fast basically it provide a fast loading because of the CDN.

[00:12:18]Now coming to the scaling comparison So vertical is killing we have we have the horizontal is killing and we have the stateless tiers. So in horizontal is killing basically in the vertical is killing we increase the like we increase the capacity of the CPU RAM the ROM and basically we have the single machine and we are increasing the all the capacity of a single machine.

[00:12:49]Uh in the horizontal is killing we are adding more.

[00:12:55]So let's say for the analogy I remember like this this is the edge.

[00:13:01]Uh so this and this is get getting connected.

[00:13:05]So in the horizontal is killing we are adding the number of nodes here.

[00:13:24]Now let's say everything is connected together.

[00:13:29]So user uh give like user provide request to the DNS then DNS provide uh request to the load balancer.

[00:13:43]From the load balancer the request goes to the app server then it goes to the cache and at the last it goes to the database.

[00:13:53]So this is how the real system uh actually is killed from the zero to millions user.

[00:14:04]So if you have any question kindly ask me in the comment section.

[00:14:09]Thank you.