Microservices on AWS
AWS Whitepaper

Benefits of Microservices

Many AWS customers adopt microservices to address limitations and challenges with agility and scalability that they experience in traditional monolithic deployments. Let’s look at the main drivers for choosing a microservices architecture.


Microservices foster an organization of small independent teams that take ownership of their services. Teams act within a small and well-understood bounded context, and they are empowered to work independently and quickly, thus shortening cycle times. You benefit significantly from the aggregate throughput of the organization.

The following figure illustrates two types of deployment structures: many small independent teams working on many deployments versus a single large team working on a monolithic deployment.


The fact that small teams can act autonomously and choose the appropriate technologies, frameworks, and tools for their domains is an important driver for innovation. Responsibility and accountability foster a culture of ownership for services.

Establishing a DevOps culture by merging development and operational skills in the same group eliminates possible frictions and contradicting goals. Agile processes no longer stop when it comes to deployment. Instead, the complete application life-cycle management processes—from committing to running code—can be automated as a Continuous Delivery process. It becomes easy to test new ideas quickly and to roll back in case something doesn’t work. The low cost of failure creates a culture of change and innovation.


Organizing software engineering around microservices can also improve the quality of code. The benefits of dividing software into small and well-defined modules are similar to those of object-oriented software engineering: improved reusability, composability, and maintainability of code.


Fine-grained decoupling of microservices is a best practice for building large- scale systems. It’s a prerequisite for performance optimization since it allows choosing the appropriate and optimal technologies for a specific service. Each service can be implemented with the appropriate programming languages and frameworks, leverage the optimal data persistence solution, and be fine-tuned with the best performing service configurations.

Properly decoupled services can be scaled horizontally and independently from each other. Vertical scaling, which is running the same software on bigger machines, is limited by the capacity of individual servers and can incur downtime during the scaling process. Horizontal scaling, which is adding more servers to the existing pool, is highly dynamic and doesn’t run into limitations of individual servers. The scaling process can be completely automated.

Furthermore, resiliency of the application can be improved because failing components can be easily and automatically replaced.


Microservices architectures make it easier to implement failure isolation. Techniques such as health-checking, caching, bulkheads, or circuit breakers allow you to reduce the blast radius of a failing component and to improve the overall availability of a given application.