Adaptability is a critical quality for a Node.js application to have in order to gracefully handle unexpected traffic spikes, infrastructure failures, and other unforeseen challenges.

In this blog series, we are exploring the three key pillars for building resilient Node.js applications:

1. Stability: Ensuring consistent and predictable behavior.

2. Efficiency: Optimizing resource utilization and minimizing latency.

3. Adapatability: Adapting to changing workloads and scaling seamlessly

In this third and final piece, we will explore how to help your application maintain predictable and efficient behaviour while being stressed with unpredictable load levels.

What does adaptability look like?

As traffic patterns change, so should your deployment. When load is high, you don’t want your application to collapse under the stress as you’ll be giving the high number of active users a bad experience. When load is low, you don’t want to be paying for more resources than you need, leading to a massively inflated cloud bill.

You need to be prepared for horizontal scaling–that is, adding more servers to the cluster running your application. At times, you may want to reach for vertical scaling, deploying larger instances when you need more headroom for average workloads, but typically, horizontal scaling is what you’ll be reaching for more often and even automatically as adding more instances doesn’t require working around inflight traffic.

Deploy with auto-scalers

Whether it be with Kubernetes or with a cloud vendor, you should always prepare your deployment systems with quick, painless, and ideally automated scaling in mind. Just checking the box of auto-scaling on its own is not enough, as not all auto-scalers are created equal. You want to understand what is the time-to-life for the environment you target.

Is it a functions-as-a-service environment with cold starts? How long do those cold starts take? How often do you encounter them? How many instances of those functions can be started at any given time (every hyperscaler has a limit)?

Is it a container orchestrator? How long does it take to schedule the workload and have the service come online?

When reacting to scale you need to be sure you can react fast enough. If you have a fast spike of traffic, you may not have time to scale up. In this situation, you may have to plan a scale up ahead of an expected spike, or, if your spikes are less predictable, you may need to over-provision enough to provide a buffer to take enough of the initial climb to compensate for the spin up time for more instances.

Clouds and Kubernetes provide a best-effort scaling strategy based on system-level metrics, but that often lacks the full picture of how a Node.js application is actually behaving as the event loop plays a very critical role in the true performance of a Node.js process. We built autoscaling into the Command Center to apply scaling decisions to a Kubernetes cluster from a much deeper understanding of the performance characteristics of your Node.js applications.

Your load, in balance

Load balancers are an essential component of horizontal scaling. If you are running in the cloud, your provider likely already manages this. However, if you’re deploying on your own hardware, you will need to make sure your traffic can be balanced effectively over as many application instances as you have available. If you’re running on Kubernetes, you’re likely going to rely on your Ingress for load balancing, but there may be cases where you want to use per-service load balancers.

Traefik is a popular option for providing more control and visibility than the default Ingress Controller. If you’re running on bare metal you may want to consider HAProxy.

Learn about what is available for your target environment and what your load balancing strategies are. Generally, a simple round-robin strategy which simply rotates between each target instance and directs the single next request at that is sufficient. However, many load balancers provide more complex strategies which can be more suitable to the characteristics of your traffic profile.

Monitor the health of your application

How will you know it’s time to scale if you don’t know your application is at risk in the first place? You need to have useful monitoring signals in place to inform you at a glance when the existing scaling strategies you have in place may be insufficient.

You can’t scale your way out of a memory leak, you can just slow it down. Similarly, you can’t scale your way out of an app that’s failing half its requests and magnifying its own traffic with clients applying their own exponential backoff strategies to keep retrying failed requests.

You need to not just know the numbers for your application health, but to understand them too. There’s a close relationship between CPU usage and event loop utilization, for example. Understanding how your application behaves under different load patterns is an important step to understanding how to scale it effectively.

There are many observability providers that offer a lot of complex functionality and capture a lot of data, but what’s most important is that the data presented is coherent and can point you in a direction to improve performance and reliability of your application. Our Command Center is designed to provide application insights in a coherent and digestible way to set you up for success when optimizing your applications.

Wrapping up

As we have seen over the course of this blog series, building a resilient Node.js application requires a multifaceted approach. By focusing on stability, efficiency, and adaptability, you can ensure your application can handle traffic fluctuations, minimize downtime, and deliver optimal performance.

What does this entail?

• Understand your traffic patterns: Analyze your user behavior to predict and prepare for traffic spikes and lulls.

• Prioritize stability: Ensure consistent application behavior and minimize errors to maintain reliability.

• Optimize for efficiency: Reduce unnecessary work, cache effectively, and leverage connection pooling to maximize resource utilization.

• Embrace flexibility: Design your application to scale horizontally and vertically to accommodate varying workloads.

• Monitor closely: Implement robust monitoring to identify potential issues and proactively scale your infrastructure.

Want to discover how Platformatic can help you auto-scale your Node.js applications, monitor key Node.js metrics, and minimize application downtime risk? Check out our Command Center.