Microservices architecture is an approach to software engineering that emphasizes small, modular pieces, introduced in the Wikipedia page as:

"a software architecture style, in which complex applications are composed of small, independent processes communicating with each other using language-agnostic APIs.

These services are small, highly decoupled and focus on doing a small task".

Best Practices Guide

  • Case study references - A blueprint model based on poster child Netflix.
  • Design Principles - The essential success software design factors.
  • Implementation - Turning on Cloud Native applications in your organization.
  • Vendors and videos - Tools and techniques showcase from tech vendors.

Netflix OSS


A keynote case study is Netflix, original pioneer of the concept and described in this 2012 presentation from Adrian Cockcroft. This Medium interview provides a comprehensive background that led them through this path.

Not only did they share their experiences of doing so, through blogs and presentations, they also literally published them as reusable Cloud best practices, distributing the components they developed to make this possible as open source software.

Organizations like Nike then adopted the same approach enabled by these building blocks to enjoy the same benefits of increased, rapid innovation, and the considerable opportunity is that any other organization is able to harness these same capabilities for the same results. RisingStack Engineering describes how Walmart and Spotify are leveraging them to build flawless user experiences for e-commerce.

References to these components are included throughout these best practices, with a view to helping others repeat these best practices in practical implementation scenarios.

API Gateways

The NewStack writes that Robust API Management is Key to Microservices, and as Microservices.io explains API Gateways are the principle means by which microservices communicate, an architecture approach Martin Fowler describes as ‘Smart Endpoints and Dumb Pipes‘.

This says that where the traditional SOA approach favours sophisticated middleware that contains in-depth logic for handing the exchanges between applications, microservices prefer a much simpler exchange mechanism, with the services themselves self-containing much more of this logic, and communications achieved via the lightweight REST protocol.

netflix-oss-150x150Netflix describe how to optimize their API in this blog, and other options include Apache Spring as API Gateway


In the NewStack article they profile Stormpath, an identity service provider, to highlight the role of Identity within the API context.

Their CEO makes the point that building microservices will require common features like authentication and so it’s a natural compliment and enabling component for a microservices architecture.

Through a new partnership with 3scale, an API gateway and management service provider, there is now a simple code snippet available on Github to allow developers to integrate a complete identity layer into their web and mobile applications.

Service Registries

A commonly agreed core of the approach is the framework required for microservices to notify and communicate with other services. For example Lori McVittie discusses the design principles, highlighting the central role of Service Registries and how they may need a dual high availability architecture.

Service registries, for the uninitiated, are kind of like the internal DNS of a microservices environment. They’re needed to manage the rapid association and disassociation with IP addresses of the containers in which the microservices are typically (but not always) hosted.

Netflix OSS modules for implementing service registries includes dynamic discovery with Eureka. Other technologies include Apache Zookeeper, which can be used for registries as Arun Gupta describes.

Stateless design

Fault Tolerant

A critical benefit of the modular approach is increased fault tolerance. This Netflix post provides a more technical deep-dive into how API and other systems isolate failure, shed load and remain resilient to failures, implementing an approach they describe as the 'circuit breaker'.

This presentation describes the design approach as one of 'Anti-fragility'.


One key argued point is that microservices should be stateless. For example in the NetStack article 10 Commandments of Microservices, they describe:

One of the key advantages of microservices is the ability to scale rapidly. Like other distributed computing architectures, microservices scale better when they are stateless. Within seconds, multiple containers can be launched across multiple hosts.

This can cause challenges, such as considering the full scope including the network, as Lori McVittie explores in this blog, and in his blog Rick Hightower proposes the opposite, that stateful services are essential to 'High Speed Microservices'.

From Monolith to Microservices

Monolith-vs-MicroservicesA key challenge for implementation is the transition from an existing legacy 'monolith' environment, to a microservices approach.

Chris Richardson describes the core challenges with this monolith approach, and The NewStack describes an architectural strategy for the transformation to microservices.

This presentation explores modernization for Java monoliths.

Cloud Native Microservices

A Microservices Application Architecture is considered one central component part of an overall Cloud Native methodology, and this implementation scenario is also helpful to understand how to adopt microservices.

Implementation Model

The approach can also be considered an ideal way of implementing this architecture. For example containers are an ideal of deploying and managing microservices.

This Newstack article provides a great overview introduction to this approach, describing how Cloud Foundry can be used as the PaaS for a Cloud Native implementation, explaining how it can be used to implement stateless microservices.

Containers and Microservices

In particular there is a natural synergy between microservices and container technologies.

Bernard Golden provides three reasons why you should always run microservices in containers:

  • Finer-grained execution environments
  • Better isolation allows for component cohabitation
  • Faster initialization and execution

Implementing microservices on AWS is explored in this presentation, and Google introduces their implementation on App Engine.

Bob Familiar introduces microservices, discussing their architecture and outlining cloud deployment scenarios, exemplified by a live demo on Microsoft Azure. The Microsoft Academy also offers a webinar introduction - Exploring Microservices in Docker and Azure.

Enterprise PaaS

Pivotal describes the relationship between PaaS & Microservices, and offers a Cloud Foundry implementation, as they explain in Deploying a Microservices Architecture with Cloud Foundry, and describe how it can accelerate projects like new mobile applications.

netflix-oss-150x150This blog describes the difference between microservices and the traditional three-tier architecture application, implemented as microservices on a PaaS, and Pivotal offers a Netflix OSS implementation on Spring Cloud.




Video Library