Scalability as a Prerequisite

Wiggins' model also stipulates that cloud applications must scale horizontally without limits. For example, if five web servers are performing their service on the platform at any given time, it should be possible to double this number immediately. Finally, the admin no longer influences scaling in PaaS, which is now the responsibility of the provider.

The Next Step: Microservices

Conventional applications are designed mostly as monolithic software: One large program offers all the functions and typically follows a Tier 3 design [2]. Many individual modules provide the desired functionality within the software, but a module cannot be used meaningfully without the application and is not executable as a standalone product.

Under these conditions, scalability becomes a problem: Even if only some of the functions used in the program need more instances, the entire monolith must be executed multiple times. Moreover, such applications are prone to error, a service in a monolithic PaaS environment is simply not available if it fails.

Such monolithic software is very difficult to handle, as well. Development can be slow because writing and subsequently testing the code requires a lot of time; thus, it implicitly violates some of the cited 12 rules. Although appropriate for classical applications, conventional applications are simply a nightmare to operate in a cloud environment.

Microservices Are Extremely Modular

Because developers no longer build just one large application, any function that might be a module in monolithic software becomes a separate service. In a microservice architecture, services must communicate with each other via a fixed protocol (e.g., APIs), leading to overhead. To compensate, the design ensures maximum flexibility: If individual services need to deal with more load, the microservice architecture allows only those services needed multiple times to launch multiple times – not the whole program.

Internal redundancy requirements can be met more advantageously with microservices, as well, because if a single sub-service fails, and the application is properly programmed, another instance of the same service simply takes over its tasks.