Evolutionary Architecture - Quick Start

A quick starter article on evolutionary architecture

Posted by Alfus Jaganathan on Tuesday, June 14, 2022

Evolutionary - Being adaptive and resilient to changes in this evolving world!

As a software architect and consultant, I used to work with several enterprise customers in my day-to-day job. One of the most common challenges that I used to face in customer places is, helping my peer team to understand and adopt to practice evolutionary architecture (often referred in general as evolutionary design).

So I thought of putting together some slides and share, that can help in quick start on evolutionary architecture principles and practices. I felt like that helped a lot in shifting the mindset from upfront architecture towards evolutionary architecture.

So I thought of sharing the same here as a simple article.

Thanks to Taavo Smith, Cedric Yao and other colleagues for providing valuable comments and suggestions helping me, enhancing the original slides.

Okay, let’s get into evolutionary architecture in a bit detail. But, please note that, we are referring evolution, with respect to software development.

In simple words, evolutionary architecture is a practice of designing and building a sustainable system that can be flexible to changes while staying healthy according to set of fitness functions. This helps in growing a system incrementally, so that it satisfies today’s need and at the same time, envisioning the future, so as to accept making continuous adjustments.

Now, let’s see why we need evolutionary architecture practices and how it helps.

I believe that, most of us would have witnessed seeing, many systems becoming obsolete and marked legacy, over a period of time, due to rapidly changing environment, which is potentially due to the below influencing factors.

  1. Technology (Ecosystem) Changes - Technology changes so fast, almost in an exponential manner. Mainframe to distributed systems, personal computers to smart devices like mobile phones and IoT devices, bare metal machines to virtual machine to containers and multi-cloud, artificial intelligence, machine learning and quantum computing, etc. are very good examples that prove the exponential velocity of technology changes, just over the past couple of decades.

  2. Business/User/Customer Driven Changes - It’s very common that the business requirement keeps changing due to aggressive business needs in this evolving world. Customers or consumers, always tends towards new market trends, which indirectly influences business requirements to change so rapidly.

So what we know here is that, these influencing factors are unavoidable, but we somehow need to protect the systems from becoming obsolete over a period of time. We can definitely achieve this by designing and building systems keeping evolutionary architecture in mind.

And let’s see how we can prepare ourselves and practice it, in our current software development environments.

Below are few of the most important tools and techniques, that I felt that, we need to utilize, so that we can practice building evolutionary architecture. Few of them are related or even subset of others, however I have called it out explicitly, for providing more clarity.

  1. Fitnesse Functions - These are tests that measure the system in alignment with architectural and organizational goals or in other words, these are guardrails that protect the system from derailing from the architectural and organizational goals. These measurements can be either subjective or objective.

    Code coverage is an example of subjective measure, guarding us not to compromize on code quality of the system, due to frequent code changes

    Performance SLO is a good example of objective measure, guarding us not to derail from the required (objective), even unknowingly, due to changes in system architecture and code

  2. Test Driven Development - This is an Xtreme Programming practice where the developer writes smaller tests and then write code to satisfy those tests. It runs with a simple cycle of Tests –> Code –> Refactor –> Tests. This practice builds confidence in refactoring or changing code at any point in time, which is a must need for the system to be adaptive for future changes.

  3. Continious Delivery - I feel like this as another crucial enabling factor in making evolutionary architecture practically possible. This provides us with continuous feedback loops that allow everyone to learn from the system being developed and evolved. This also provides ability to hook in some of the fitnesse functions as guardrailing gates.

  4. Prioritizing Non-Functional-Requirements (NFRs) - Always ask questions like Is this NFR a problem now?, Will this NFR be a future problem? and Could this NFR be a future problem? and prioritize them in your systems roadmap accordingly. This will help us organically shifting our mindset from must to solve today’s and tomorrow’s problem right now towards solve the problems as and when they evolve.

    For e.g. When you are using a database in the software system, you may think of adding a cache in between to solve a potential future problem, which inturn leads to upfront architecture. This can be easily avoided by asking the above questions against the NFR.

  5. Telemetry - This as another crucial enabling factor in making evolutionary architecture practically possible. A constant monitoring of the system with respect to Application performance monitoring(APM) and other system health monitoring, let’s us to learn and measure the current state of the system so as to act as needed, by asking the above mentioned questions, rather than designing the system based on too much of futuristic predictions and trying to solve everything upfront.

  6. Adopt to Fail-Fast principle - This is very much related to a mindset where we are ready to accept failures, but as quick as possible. This can be achieved by practicing lean methodology where we can quickly find the failures, but at the same time, quickly learn and improve using optimized solutions.

  7. Design Patterns - Usage of right design pattern in the right place, helps in building a healthy system which can be easier to change and at the same time, less expensive to maintain.

    As an example, a simple design pattern which comes to my mind at the moment is, Anti-Corruption Layer (ACL), which helps seperating systems that doesn’t share semantics, helping in isolating those systems for a good cause, typically used in staged modernization environments

  8. Event-Driven Architecture - This is yet another architectural pattern I like the most due to its nature of eliminating the tight coupling between any systems that needs to integrate and work together. This way, it helps the system to easily add or remove other systems from its current ecosystem.

  9. Domain Driven Design - I brought this here for a simple reason, where DDD helps in building a system using domain models as the core of the model programming, which intern simplifies making non-breaking changes as it constitutes well-defined boundaries.

  10. Modular Monolith/ App Continium - To me, these are simple techniques, that help in incrementally changing the code structure based on the evolving nature of needs, that happens at a particular inflection point.

Most of us are scared to follow and practice evolutionary architecture is due to side-effects like very frequent changes in code, code structure, system architecture, system technology, etc. But nothing to worry, as long as we have used the above mentioned right set of tools and techniques.

Please read this book on Building Evolutionary Architectures, if you wish to learn more.

Hope this article gave a good start, to think and urge learning more about evolutionary architecture!


Below are few of the most important articles that I used for my reference, while writing this article.

A realtime case study from VMware Tanzu Labs (Added on 06/17/2022)

I just came across this blog from Tanzu labs, which sounded like a very good example showing the value of evolutionary architecture mindset. Please have a look at the article An Architecture Path to Mainframe Modernization

Love helping the community!

comments powered by Disqus