Evolution of Business Logic from Monoliths through Microservices, to Functions

As technology has progressed over the last decade, we’ve seen an evolution from monolithic applications to microservices and are now seeing the rise of serverless event driven functions, led by AWS Lambda. What factors have driven this evolution? Low latency messaging enabled the move from monoliths to microservices, low latency provisioning enabled the move to Lambda.

To start with, ten years ago, a monolithic application was the best way to deliver business logic, for the constraints of the time. Those constraints changed, and about five years ago the best option shifted to microservices. New applications began to be built on a microservices architecture, and over the last few years, tooling and development practices changed to support microservices. Today, another shift is taking place, to event driven functions, because the underlying constraints have changed, costs have reduced, and radical improvements in time to value are possible.

Advances in delivery technology provide stepping stones for improvements in time to value, but there are other underlying changes that have caused a series of transitions in best practices over the last decade.

The optimal size for a bundle of business logic depends upon the relative costs in both dollars and access time of CPU, network, memory and disk resources, combined with the latency goal for the service.

There have also been huge changes in “people and process” over the last decade. Let’s consider a hypothetical monolith built by 100 developers working together. To coordinate, manage test and deliver updates to this monolith every few months it’s common to have more people running the process than writing the code. Twice as many project managers, testers, DBA’s, operators etc. organized in silos, driven by tickets, and a management hierarchy demanding that everyone write weekly reports and attend lots of status meetings as well as find time to code the actual business logic!

The combination of DevOps practices, microservices architectures, and cloud deployments went hand in hand with continuous delivery processes, cellular based “two pizza team” organizations, and a big reduction in tickets, meetings and management overhead. Small groups of developers and product managers independently code, test and deploy their own microservices whenever they need to. The ratio of developers to overhead reverses, with 100 developers to 50 managers. Each developer is spending less time in meetings and waiting for tickets, getting twice as much done with a hundred times better time to value. A common shorthand for this change is a move from project to product. A large number of project managers are replaced with far fewer product managers. In my somewhat contrived example, 150 people are producing twice the output that 300 people used to. Double the return a hundred times sooner, on half the investment. Many organizations have been making this kind of transition and there are real examples of similar improvements.