How Do I Adopt?

A developer led, incremental strategy for adopting microservices gives the best chance for success.

In a microservices architecture, individual development teams are empowered to make their own technology decisions. By decentralizing architectural governance, teams are able to rapidly make technical decisions and move forward.

Similarly, adopting a microservices architecture should be an organic, iterative process driven from the bottom up. Consider the difference in these approaches:

Adoption strategy Developer led CTO driven
Technology strategy Leverage existing stack Replace existing stack
Standards strategy Great developer experience Architectural standards

Adoption Strategy

While some organizations have succeeded with a top-level mandate to shift to microservices, most organizations that have adopted microservices have had initiatives driven by a handful of developers. In a bottom up scenario, the initial development team experiments with a specific development challenge, and iterates based on the specific scenario. This results in a working end-to-end use case. In a top down scenario, more upfront work occurs on standardization and technology selection – a process that may or may not be necessary.

Technology Strategy

A common misconception is that a new technology stack is required to adopt microservices. While some additional technology is needed for microservices, there is rarely a need to replace your existing technology stack. Instead, with microservices, consider incrementally adding technology as the need arises.

Standards Strategy

The traditional approach to standardization is to create some sort of architectural rules, perhaps embodied in an Architectural Guide, and, in large organizations, enforced by an Architectural Review Board. The microservices approach eschews this heavy, cumbersome strategy. Instead, organizations successfully using microservices usually have a fanatical focus on the developer experience. By making it as easy as possible to implement a microservice in a specific way (via powerful libraries, great documentation, example code), standards are organically adopted.