Scaling Your Website? Choose the Right CMS Architecture

Scaling Your Website Infrastructure

Today's customers demand availability at all times. This means they want your content and services whenever and wherever they choose. For companies that experience massive growth, it can be challenging and expensive to scale their CMS and other systems to meet these demands.

Wells Fargo, for example, plans to make 10% increases in technology spending year-over-year after having large-scale outages. Companies are recognizing the need to have highly available and scalable systems that keep them away from the negative headlines.

Let's look at what website scaling is and how particular software architecture design decisions enable efficient scaling.

What Is Website Scaling?

Website scaling is a way to handle additional workloads by adjusting your infrastructure. The increased workload could be anything from an influx of users to a large volume of simultaneous transactions or anything else that pushes the software beyond its designed capacity.

There are two types of infrastructure scaling: vertical and horizontal. As we'll see later, this is only part of the equation when it comes to meeting heavier workloads and traffic demands from users hitting your website.

Vertical Scaling

With vertical scaling, you increase hardware capacity to give your software more resources to handle heavier workloads. Vertical scaling could mean switching to a server with a faster CPU, additional memory, or a variety of other factors that affect a computer's performance. Cloud services like AWS make it easy to increase computing power as needed to scale vertically. While vertical scaling is simple to achieve, it can quickly become costly, and there's a point where you can upgrade a piece of hardware any more and will need to add more servers to continue scaling.

Horizontal Scaling

To scale horizontally, you provision new servers to run your software on - for example, with additional instances. With more instances of your software running, the workload can be distributed across them to process more of the workload at the same time. Typically, companies configure load balancers to distribute web traffic across software instances automatically. Horizontal scaling may be effective, but it also adds complexity to your infrastructure.

Why Does Software Architecture Matter?

While it's one thing to have scalable hardware or cloud infrastructure, if your software isn't designed with scalability in mind, it won't be able to easily utilize the additional computing resources. There could be any number of bottlenecks from the database to high latency processes that can affect performance and uptime. That's why you need a software architecture that can handle increased workloads in-line with your infrastructure capacity.

What Makes Software Scalable?

Any software you invest in should be designed to handle workloads beyond its original capacity. Companies need software that will grow with them. What this means is you need software that runs stateless, uses decoupled microservices, avoids databases, and reduces latency.

Make Software Stateless

If software is designed to store state on a server, that means any related requests need to be routed to that specific server. This architecture would eliminate the ability to distribute work on whichever server is available using a load balancer. Caching state is crucial for performance, but it becomes detrimental if it prevents horizontal scaling.

Many modern applications are taking stateless a step further with serverless architectures. With this type of application, there's no state stored at all, so it can run using serverless services without developers having to know anything about the architecture. That means these applications are both scalable and elastic.

Decoupled Microservices

Traditional monolithic applications are slow to deploy and take up a lot of system resources to run. That's part of the reason why many companies are turning to microservices for modern application architectures. By decoupling services into many smaller applications that are deployable on their own, it's possible to scale only the particular portions of the system that need more processing power. While microservices may bring in added complexity, the tradeoff is better utilization of computing resources and easier implementation of elastic processes.

Avoid Databases

Traditional databases, whether SQL or NoSQL, are familiar for most software developers, and for that reason, they're the simple way to store data. The problem is, they can be challenging to use at scale with full data replication because write procedures become a bottleneck.

Instead, you could use data partitioning to split the data between various servers, but this becomes complex to maintain and doesn't work well for planet-scale deployments. If data sets are spread across different servers, it's challenging to run queries on the whole dataset. Not only that, but the servers are likely geographically distributed, so high latency can become an issue. That's why many newer software architectures do not rely on a database at all, instead using distributed repositories that scale naturally.

Reduce Latency

For software to be scalable, you want much of the heavy lifting done close to users. When scaling horizontally, for example, communication between systems located in various geographic locations can lead to high latency, and create a bottleneck for the software.

Another exciting area that's growing in popularity is edge computing. By bringing computing power closer to users, you can minimize the time it takes to communicate with servers and lower traffic demands on critical system resources. Edge computing is another way to reduce latency and eliminate communication bottlenecks.

Further Reading: AWS Snowball Edge: Low-Latency and Remote Content Delivery 

The Scalable Architecture of CrafterCMS

Scalability isn't an add-on feature, but crucial to the long-term value of any software. Most CMSs from traditional to modern headless solutions aren't built with scalability in mind. CrafterCMS is different.

With CrafterCMS, scalability is a fundamental part of the architecture. The software uses a Git-based repository, eliminating the bottlenecks a traditional database causes. It's also cloud-native and stateless, with a microservices architecture that makes scaling specific services with a platform like Kubernetes straightforward. It's also serverless, so components are completely decoupled from each other. The shared-nothing architecture means that everything can be scaled independently - up or down - so that you have a truly scalable and elastic CMS solution. With CrafterCMS, scaling your website performance is as simple as spinning up new instances - locally within a single region or globally across multiple regions.