DEV Community: Mohamed Galhoum

Vertical vs. Horizontal Scaling: How to Handle More Traffic 🚀

Mohamed Galhoum — Fri, 16 Oct 2026 12:08:15 +0000

As your application grows, a single server may struggle to handle increasing traffic, leading to slower responses, timeouts, and downtime.

In system design, there are two main approaches to scaling: Vertical Scaling and Horizontal Scaling.

1. Vertical Scaling (Scale Up) ⬆️

Vertical scaling means upgrading an existing server by adding more CPU, RAM, or storage.

      Users
        |
        v
  +-------------+
  | Web Server  |
  | More CPU/RAM|
  +-------------+

✅ Advantages: Simple to implement, fewer architectural changes, and easier state management.

❌ Disadvantages: Hardware limitations, potentially expensive upgrades, and a single point of failure if only one server exists.

2. Horizontal Scaling (Scale Out) ➡️

Horizontal scaling means adding more servers to distribute the workload.

          Users
            |
            v
     +--------------+
     | Load Balancer|
     +--------------+
       /     |     \
      v      v      v
    App 1  App 2  App 3
       \     |     /
         Database

✅ Advantages: More capacity, flexible scaling, and improved availability when designed with redundancy.

❌ Disadvantages: Greater complexity, distributed state management, and potential bottlenecks in shared dependencies such as databases.

3. Why Do We Need a Load Balancer?

A load balancer distributes incoming requests across multiple application servers.

It helps to:

Distribute traffic across available instances.
Perform health checks and avoid routing new requests to unhealthy servers.
Improve availability when an application instance fails.
Support horizontal scaling as new servers are added.

Remember: the load balancer and database can also become bottlenecks or single points of failure if they aren't designed appropriately.

4. Quick Comparison

Vertical Scaling	Horizontal Scaling
Upgrade one server	Add more servers
Simpler architecture	More complex architecture
Limited by machine capacity	Capacity distributed across machines
Local state is often simpler	Shared state may be required
Good for simpler workloads	Useful for growing workloads

Final Thoughts 💡

Vertical scaling makes one server more powerful, while horizontal scaling distributes work across multiple servers.

In practice, we can combine both approaches. The right choice depends on traffic, cost, performance, and availability requirements.

My advice: Start simple, measure your bottlenecks, optimize first, and scale when necessary.

🚀 React List Virtualization: Boost Performance When Rendering Thousands of Items

Mohamed Galhoum — Sat, 10 Oct 2026 06:50:28 +0000

🚀 React Performance Tip: List Virtualization

Rendering thousands of items in React can hurt performance, increase DOM size, and make scrolling feel sluggish.

💡 The solution? List Virtualization!

Instead of rendering every item in a large list, virtualization renders only the items currently visible in the viewport, plus a small buffer.

🔥 Popular React Virtualization Libraries:

🔹 TanStack Virtual — Flexible, lightweight, and highly customizable.

🔹 react-window — A simple option for efficiently rendering large lists and grids.

🔹 React Virtuoso — Great for chat applications, dynamic-height lists, and infinite feeds.

🔹 MUI X Data Grid — Ideal for data-heavy tables with built-in virtualization.

🔹 AG Grid — Powerful for enterprise applications with large datasets.

📌 Why use list virtualization?
✅ Reduce the number of DOM elements.
✅ Improve rendering performance.
✅ Make scrolling smoother.
✅ Reduce the work required for layout and painting.
✅ Build more responsive interfaces for large datasets.

💻 Pro tip: Virtualization works best when combined with stable keys, efficient React components, and proper data fetching strategies.

🎯 If you're building a React application that displays thousands of records, consider virtualization before rendering the entire list at once!

System Design Fundamentals: The 5 Dimensions of Scalability — Data, Complexity & Geographic Growth

Mohamed Galhoum — Fri, 09 Oct 2026 17:14:48 +0000

Let’s continue our discussion about Scalability and its different dimensions.

Last time, we discussed the first two dimensions of system growth. Today, let’s explore the remaining three.

🔹 3. Growth in Data Volume

Over time, any successful system will likely start dealing with increasingly large amounts of data.

Consider a platform like YouTube. Every day, the platform receives new videos, new users, new comments, watch history records, logs, metadata, and much more.

As a result, the amount of data continues to grow over time.

This creates new challenges in storage, databases, data processing, and data retrieval.

We need to design our systems to handle this increasing data volume without significantly degrading performance.

🔹 4. Growth in Complexity

Initially, we might build a simple application where all the business logic lives inside a single monolith.

But as time passes, the system grows.

The number of features increases, integrations become more numerous, and the number of components expands.

We might eventually start splitting the system into independent services, such as:

User Service
Payment Service
Order Service
Notification Service

This makes the overall architecture more complex.

Now, we have more components, more dependencies, and communication between services becomes an essential part of the system.

It's important to understand that Scalability isn't just about handling more users. We also need to understand how to manage the complexity that comes with system growth.

🔹 5. Growth in Geographic Reach

Initially, a system might serve users in just one country.

But as the company expands, it may start serving users across multiple countries and geographic regions.

This introduces new challenges.

For example, we might need to deploy servers in different regions to reduce latency.

We might need data replication across regions.

We might also need high availability, ensuring that if one region experiences a failure, other regions can continue operating.

As geographic reach increases, the architecture must evolve to serve users in different locations effectively.

So, when we talk about Scalability, we shouldn't immediately jump to the conclusion:

"Let's add more servers."

Instead, the first question we should ask is:

What exactly is growing?

Is the number of users increasing?
Is the number of features growing?
Is the volume of data increasing?
Is the system becoming more complex?
Is the geographic reach expanding?

Once we understand exactly what is growing, we can start thinking about the right architecture and design decisions to address that specific type of growth.

Ultimately, the goal of scalability isn't simply to allow a system to serve more users.

It's to enable the system to grow continuously while maintaining performance, reliability, and availability.

That's what makes Scalability one of the most important concepts to understand in System Design.

May Allah teach us what benefits us, increase us in knowledge, and keep us all safe and well. ❤️

System Design Fundamentals: Understanding Scalability and the Dimensions of System Growth

Mohamed Galhoum — Fri, 09 Oct 2026 17:04:54 +0000

One of the topics I’m really interested in is System Design & Distributed Systems, and one of the most important concepts we encounter in System Design is Scalability.

As a system grows, whether the number of users increases, the number of requests goes up, or the amount of data grows, its performance may start to degrade.

This raises an important question:

How can we design a system that handles growth without sacrificing performance?

That’s where Scalability comes in.

Scalability is the ability of a system to handle an increasing workload by adding resources or evolving its architecture, while maintaining acceptable performance as demand grows.

In simple terms, as a system grows, its load increases, and we need to scale it to accommodate that growth.

A scalable system is designed to evolve over time without every increase in workload leading to major problems with performance, availability, or reliability.

But how exactly can a system grow?

Growth doesn’t simply mean having more users.

A system can grow across multiple dimensions, and there are five major forms of growth. Today, let’s explore two of them.

🔹 1. Growth in the User Base

Imagine a social media platform that starts with 10,000 users.

Over time, the platform grows and reaches millions of users.

Naturally, as the number of users increases, the number of requests reaching the system is likely to increase as well.

If the system was initially designed to handle a relatively small number of users, it may start struggling as the traffic grows significantly.

That’s why we need an architecture that can scale to accommodate increasing traffic and workload while maintaining a good user experience.

🔹 2. Growth in Features

Imagine starting with a simple e-commerce website.

Initially, users can browse products, check out, and pay using a credit card.

Over time, however, the company starts introducing new features, such as:

Digital Wallets
Cash on Delivery
Discount Systems
Recommendation Systems
Order Tracking

Every new feature adds value to the system, but it can also increase its complexity.

As the number of features grows, the existing architecture may need to evolve to accommodate new functionalities while keeping the system maintainable and reliable.

In this case, the system isn’t just serving more users; it’s also doing more things.

Understanding these different dimensions of growth is an important first step toward designing scalable systems.

May Allah teach us what benefits us and increase us in knowledge. Wishing you all continued success and well-being. ❤️