Skip to main content

Gall’s law and how it applies to software architecture

When it comes to software architecture, complexity can quickly become a daunting adversary. In the ever-evolving world of technology, designing software systems that are not only functional but also maintainable and scalable is a constant challenge. That's where Gall's Law comes into play.

Named after John Gall, an American pediatrician, and systems theorist, this principle sheds light on the fundamental idea that underlies software architecture:

"A complex system that works is invariably found to have evolved from a simple system that worked."

In this post, we'll delve into Gall's Law and explore its profound implications for software architecture.

Generated by Dall-E 2

Understanding Gall's Law

John Gall's Law, often paraphrased as "Complex systems evolve from simple systems that worked" encapsulates a deep insight into how complex systems come into existence. Gall originally formulated this law in the context of systems theory, but it has wide-ranging applications, including software architecture. At its core, Gall's Law underscores the idea that it is often more effective to start with a simple, working system and iteratively build upon it as necessary.

This approach is in stark contrast to attempting to design a complex system from scratch, which is inherently challenging and prone to failure.

Implications for Software Architecture

Applying this law can have a big impact in how we design and architect our software. It advocates the following concepts:

Evolutionary Architecture: Gall's Law promotes the concept of evolutionary architecture in software design. It suggests that architects should begin with a minimal viable product (MVP) or a simple system that meets the immediate requirements and then iteratively enhance it based on real-world usage and changing needs. This incremental approach allows for a more adaptive and flexible architecture.

Iterative Development: Software architects should embrace an iterative development process where they continually refine and expand the system in response to feedback and evolving requirements. This not only reduces the risk of building a system that doesn't meet the actual needs but also avoids over-engineering from the outset.

Simplicity is fundamental: Gall's Law reinforces the importance of simplicity in software architecture. Starting with a simple, functional system provides a solid foundation for future growth. Simplicity makes the architecture more understandable, maintainable, and resistant to bugs, which are crucial qualities as the system evolves.

Avoiding Big Design Up Front (BDUF): Big Design Up Front is an approach where architects attempt to anticipate all possible requirements and design the entire system in detail before implementation begins. Gall's Law suggests that this approach is inherently risky, as it is challenging to predict all future needs accurately. Instead, architects should focus on designing the simplest system that can deliver value and evolve it as needed.

Embracing Change: In the fast-paced world of software development, change is inevitable. Gall's Law encourages architects and developers to embrace change as a natural part of the system's evolution. This means that software architecture should be designed to accommodate change gracefully, making the system more robust and adaptable.


Gall's Law offers a powerful perspective on software architecture. It reminds us that complexity should not be our starting point but the result of a thoughtful, iterative process. By beginning with a simple, working system and evolving it over time, we can create software architectures that are more resilient, maintainable, and better aligned with real-world needs. 

In today's dynamic software development landscape, the wisdom of Gall's Law is more relevant than ever. By embracing its principles, software architects can navigate the complexities of their craft with greater confidence and success.

Popular posts from this blog

DevToys–A swiss army knife for developers

As a developer there are a lot of small tasks you need to do as part of your coding, debugging and testing activities.  DevToys is an offline windows app that tries to help you with these tasks. Instead of using different websites you get a fully offline experience offering help for a large list of tasks. Many tools are available. Here is the current list: Converters JSON <> YAML Timestamp Number Base Cron Parser Encoders / Decoders HTML URL Base64 Text & Image GZip JWT Decoder Formatters JSON SQL XML Generators Hash (MD5, SHA1, SHA256, SHA512) UUID 1 and 4 Lorem Ipsum Checksum Text Escape / Unescape Inspector & Case Converter Regex Tester Text Comparer XML Validator Markdown Preview Graphic Color B

Help! I accidently enabled HSTS–on localhost

I ran into an issue after accidently enabling HSTS for a website on localhost. This was not an issue for the original website that was running in IIS and had a certificate configured. But when I tried to run an Angular app a little bit later on http://localhost:4200 the browser redirected me immediately to https://localhost . Whoops! That was not what I wanted in this case. To fix it, you need to go the network settings of your browser, there are available at: chrome://net-internals/#hsts edge://net-internals/#hsts brave://net-internals/#hsts Enter ‘localhost’ in the domain textbox under the Delete domain security policies section and hit Delete . That should do the trick…

Azure DevOps/ GitHub emoji

I’m really bad at remembering emoji’s. So here is cheat sheet with all emoji’s that can be used in tools that support the github emoji markdown markup: All credits go to rcaviers who created this list.