Let’s take an example of a website that announces a “flash sale” at midday. Within no time, thousands of people will begin logging into the site, browsing their products, and putting them into their shopping basket.
Initially, everything seems okay. But then, the loading times for product pages become slow, checkout timeouts occur, and users are refreshing the web page.
The servers are up and running, but they cannot handle all the requests.
It becomes difficult for applications to cope with traffic spikes because they have been overloaded with more work than what their infrastructure is capable of handling. Fortunately, there are three techniques that can mitigate the stress on websites – caching, content delivery networks, and message queues.
Why do websites struggle during traffic spikes?
Every visit made to a website utilizes computer resources. A visit to a product page may result in a database query, some business logic processing, and transfer of images and other data.
When you scale this up to many visits happening at once, it is evident that the infrastructure is not endless.
Some of the issues that are common include:
- CPU overload: The application servers are not able to process the requests fast enough.
- Database overload: Many queries compete for limited connections.
- Network bottlenecks: Large volumes of data consume limited bandwidth.
- Background processing: Emails and other processes compete with necessary processes.
Adding more servers can help, but reducing unnecessary work is often equally important.
1. Using caching to reduce overload
The concept of caching involves storing frequently accessed data on a temporary basis so that the application may fetch that without redoing the operation.
Imagine the same case of an e-commerce website showing some product descriptions to 5,000 users.
In the absence of caching, the application would need to look up that same data over and over again from the database.
Common caching applications include:
- Product descriptions and category information
- Frequently accessed database query results
- Website configuration settings
- Public API responses
- Reusable page components
Application-level caching can be achieved by using tools like Redis. However, caching needs to be done properly.
Stocks, account information, and payment information can be updated often. Using out-of-date information can cause issues during checkout.
Proper expiration policies need to be set, and information needs to be invalidated when the underlying data is updated.
2. CDNs being useful during high traffic
Content Delivery Network stores website content on servers located at various geographic locations. As opposed to downloading all images, style sheets, or JavaScript files from the original host server, the visitor gets the cached content from a closer CDN location.
For instance, the user from Chennai browsing through a site hosted in Mumbai may get their static files from a nearer CDN edge server.
The loading time is thus reduced, and the number of requests to the origin server is also minimized.
CDNs are particularly useful for:
- Product images and promotional banners
- CSS and JavaScript files
- Downloadable documents
- Video files and other static media
A CDN can also help to distribute traffic through its network rather than directing all requests to a single server.
Nevertheless, CDNs will not automatically resolve database bottlenecks or slow checkouts.
Caching controls should be properly applied to personalized pages and private information.
For businesses unfamiliar with the technology, this guide to content delivery networks explains how edge servers and origin infrastructure work together.
3. Message queues preventing application slowdowns
Not all operations in a web application need to be performed instantly. Consider what happens next after the user makes his order.
There may be an operation that needs sending an email, analytics update, warehouse notification, and invoice creation. Doing all those within the same request will reduce performance.
With message queues, the application can separate these operations.
The checkout service enqueues the operations, and background workers perform them separately.
There are technologies like RabbitMQ, Apache Kafka, or even queue services managed by the cloud that satisfy the messaging needs.
Benefits include:
- Faster responses for customers
- Reduced pressure on application servers
- Better handling of temporary processing backlogs
- Independent scaling of background workers
Queues still require monitoring. If tasks arrive faster than workers can process them, the backlog grows.
Businesses should also implement retry limits, failure handling, and safeguards against duplicate processing.
How do caching, CDNs, and queues work together?
These technologies protect different parts of the application.
| Technology | Main purpose | Example |
| Caching | Reduces repeated processing | Reusing product information |
| CDN | Reduces origin traffic | Serving product images |
| Message queue | Handles background tasks | Sending order emails |
Consider an online retailer preparing for a major promotional event.
The CDN serves product images and static website files. The application cache reduces repeated database queries. Message queues handle confirmation emails and other nonessential background operations.
Together, these systems allow application servers to focus more resources on activities such as checkout and inventory management.
When should businesses add more server capacity?
Caching, CDNs, and queues can reduce infrastructure pressure, but they cannot eliminate every bottleneck.
A growing website may still require additional CPU, memory, or application instances.
Businesses can deploy applications on a Linux virtual machine and adjust their infrastructure as demand changes.
For example, an online retailer could distribute requests across multiple virtual machines using a load balancer.
Autoscaling can add application instances when traffic increases, provided the infrastructure and application are configured to support it.
However, scaling requires preparation. New instances take time to start, and databases may remain bottlenecks even when application capacity increases.
The most reliable approach combines sufficient computing resources with efficient application design.
Verdict
Issues arise when each request places additional stress on the application’s infrastructure.
Caching helps eliminate redundancy, CDNs deliver content more effectively, and queues avoid having background tasks affect crucial requests.
In combination with scalable servers, load testing, and monitoring tools, these techniques may be useful for companies dealing with high traffic times.
Frequently asked questions
What is the difference between caching and a CDN?
Caching temporarily stores reusable information. A CDN uses geographically distributed servers to deliver cached content closer to users.
Can a CDN prevent a website from crashing?
A CDN can reduce origin traffic and improve content delivery, but it cannot resolve every application or database bottleneck.
Do small websites need message queues?
Not always. Queues become useful when background tasks slow down important operations or require independent processing.
Is Redis a caching tool?
Yes. Redis is an in-memory data store commonly used for caching, session management, and other low-latency operations.
Can virtual machines handle sudden traffic spikes?
Yes, when sufficient resources and appropriate scaling mechanisms are available. Load balancing and autoscaling can help distribute increased demand.