Microservices help your organization to the extend that they enable Flow.
Consider the case where you have a monolith, and all value streams pass through it:
That means every single change has the potential to wait on the availability of:
- Folks experienced enough to review the changes
- Availability of scarce automated test resources
- Availability of a single deployment pipeline
In Dr. Eliyahu M. Goldratt’s triumphant book The Goal, which introduced his Theory of Constraints, the characters discover that in their manufacturing flow they had certain widgets that passing through their bottleneck but that they didn’t need them to. As part of step 3 of the Five Focusing Steps, subordinate & synchronize to the constraint, they realized these subprocesses were not synchronized to the constraint, and they removed them from that flow.
Microservices allow you to do the same with your code base. If every feature has to pass through the same project, then you get batching and queueing, giving each change a longer lead time. With a longer lead time, teams are encouraged to make changes larger, which begets even more waiting, reduction in quality, and higher risk. A vicious cycle if ever there were one.
You start to benefit from microservices when you start logically decoupling your different workflows:
Now changes can proceed independent of everything else. Where you still have dependency, you find them in relatively stable places. Scott Bellware wrote the excellent Afference: The Silent Killer that dives into recognizing the difference between healthy and unhealthy coupling.
Note: This. Is. Hard. To. Do. It’s a bit like trying to separate the ingredients of a cake after they’ve been mixed together. You might end up needing some help with it.
You’ll realize this when you embrace The Key Point™: a monolith is a data model that requires all data points to be in transactional consistency with one another. Through the murky “boundaries” in a typical monolithic project, every business operation becomes coupled to every other business operation. If you miss that point, your microservices effort will likely just result in physical decoupling while retaining all the logical coupling:
All you’ve added is the additional complexity of a distributed system.
