In this chapter, we learned how to design Node.js architectures that scale both in capacity and complexity. We saw how scaling an application is not only about handling more traffic or reducing the response time, but it's also a practice to apply when we want better availability and tolerance to failures. We saw how these properties often are on the same wavelength and we understood that scaling early is not a bad practice, especially in Node.js, which allows us to do it easily and with few resources.

The scale cube taught us that applications can be scaled across three dimensions. We dived into the two most important of them, the x-and y-axes, allowing us to discover two essential architectural patterns, namely, load balancing and microservices. We should know by now how to start multiple instances of the same Node.js application, how to distribute the traffic across them, and how to exploit this setup for other purposes such as fail tolerance and zero-downtime restarts. We also analyzed how to handle the problem of dynamic and autoscaled infrastructures; we saw that a service registry can really come in useful for those situations. However, cloning and load balancing cover only one dimension of the scale cube, so we moved our analysis to another dimension, studying in more detail what it means to split an application by its constituent services, by building a microservice architecture. We saw how microservices enable a complete revolution in how a project is developed and managed, providing a natural way to distribute the load of an application and split its complexity. However, we learned that this also means shifting the complexity from how to build a big monolithic application to how to integrate a set of services. This last aspect is where we focused the last part of our analysis, showing some of the architectural solutions to integrate a set of independent services.

In the next chapter, we will have the chance to analyze in more detail, the messaging patterns we discussed in this chapter in addition to more advanced integration techniques, useful when implementing complex distributed architectures.