Migrating a monolithic system to an ecosystem of microservices is an epic journey. The ones who embark on this journey have aspirations such as increasing the scale of operation, accelerating the pace of change, and escaping the high cost of change. Deciding what capability to decouple when and how to migrate incrementally are some of the architectural challenges of decomposing a monolith to an ecosystem of microservices. These small loosely coupled services are not a panacea problem solver for all projects but they are a great tool to evolve a system. The architecture offers flexibility and deployment independence, facilitating easier maintenance and automated testing.

The SIMPLE Experience

Start with a simple service

The best way to migrate a monolithic application to microservices is to start with a simple service, but then draw out services that are based on vertical capabilities that are important to the business and subject to frequent change. These services should be large at first and preferably not dependent upon the remaining monolith. eSimplicity ensures that each step of migration represents an atomic improvement to the overall architecture.

Split sticky capabilities early

We may find ourselves limited with the capabilities that we can decouple next without a dependency back to the monolith. The root cause of this, is often a capability within the monolith that is leaky, not well defined as a domain concept, with many of the monolith capabilities depending on it. In order to be able to progress, eSimplicity developers identify the sticky capability, deconstruct it into well-defined domain concepts and then reify those domain concepts into separate services.

Decouple vertically and release the data early

The main driver for decoupling capabilities out of a monolith is to be able to release them independently. This first principle should guide every decision that developers make around how to perform the decoupling. A monolithic system often is composed of tightly integrated layers or even multiple systems that need to be released together and have brittle interdependencies. For example, in an online retail system, the monolith composed of one or multiple customer facing online shopping applications, a back-end system implementing many of the business capabilities with a centrally integrated data store to hold state.

Most decoupling attempts start with extracting the user facing components and a few facade services to provide developer friendly APIs for the modern UIs, while the data remains locked in one schema and storage system. Though this approach gives some quick wins such as changing the UI more frequently when it comes to core capabilities the delivery teams can only move as fast as the slowest part, the monolith and its monolithic data store. Simply put, without decoupling the data, the architecture is not microservices. Keeping all the data in the same datastore is counter to the Decentralized Data Management characteristic of microservices.