I've been thinking about something I find strangely beautiful about software architecture: good architecture doesn't give you more ways to build a system. It gives you fewer.
That sounds like a contradiction. We usually talk about good architecture in terms of flexibility, extensibility, and reuse. But there is another kind of flexibility that is much more valuable: not having to make the same decision again.
We already have a name for part of this idea: Don't Repeat Yourself. But I think DRY goes deeper than avoiding duplicated code.
Don't repeat decisions.
If I've already solved a problem correctly, why should the next developer have to solve it again?
- Why should five different modules each implement their own version of authorization?
- Why should every developer remember how tenant isolation is supposed to work?
- Why should every controller know how a user is authenticated?
Every time we allow those decisions to be made independently, we create another opportunity for the system to drift.
And that's where poorly structured software starts becoming dangerous. The problem isn't usually that one piece of code is particularly bad. It's that the system has too many places where important decisions can be made.
One developer handles something one way. Another handles it slightly differently. A third doesn't know either convention exists and creates a third solution. Each one makes sense in isolation. Together, they create unintended consequences.
A change in one place behaves differently somewhere else. A security rule gets missed. Data crosses a boundary it shouldn't. A bug appears several layers away from the decision that caused it.
The complexity isn't necessarily in the code.
It's in the number of possible ways the system can behave.
This is where I think architecture becomes really interesting. You are not just organizing code. You are designing the boundaries that determine how the code is allowed to behave.
You take a problem, solve it once, encapsulate that solution, and expose only what the rest of the system actually needs. The implementation becomes someone else's problem. The decision becomes part of the architecture.
Now the next developer doesn't need to understand everything that went into solving the problem. They just need to use the boundary.
That's an enormous reduction in cognitive load.
And it isn't unique to software.
Think about a good design system. If every screen starts with a completely blank canvas, every designer has to decide typography, spacing, colors, hierarchy, interaction patterns, and the visual language of every component.
There are almost infinite possibilities.
A good design system deliberately takes many of those possibilities away. You have a palette. A type scale. A spacing system. Components that already know how they should look and behave.
That sounds restrictive until you actually use one.
Then something interesting happens: you become more creative because you have fewer things to figure out.
You're no longer spending your creative energy deciding how every element should look. You can spend it deciding what the interface should accomplish.
Constraints don't necessarily limit creativity. The right constraints concentrate it.
Software architecture can do the same thing.
Instead of giving every piece of the application infinite freedom, we establish conventions and boundaries that make the correct path obvious.
And this is where good architecture starts preventing bugs rather than merely making them easier to fix.
Of course, constraints carry their own risk. A boundary that is too rigid, or a decision that later proves incomplete, can become an obstacle instead of a safeguard.
The answer isn't to avoid constraints. It's to make them changeable.
The boundaries we build should protect the things we already understand while leaving room to change the things we don't. The implementation behind a boundary can evolve without requiring everything around it to be rewritten.
That distinction matters. We're not trying to make today's decisions permanent. We're trying to make today's decisions contained.
If we learn something new, or the requirements change, we should be able to replace the solution without dismantling the structure around it.
In other words, good architecture shouldn't trap you inside your decisions. It should give your decisions somewhere safe to live.
That lets us have both things we usually think are opposites: strong boundaries and the freedom to improve what lives behind them.
As part of the systems we've been building, we've started putting these kinds of boundaries directly into the foundation of the application. For example, when something belongs to a particular customer, the system now knows that relationship and enforces it for us.
The developer working on a feature doesn't have to remember every rule about who should be able to see or change that information. They build within the boundary, and the infrastructure takes care of enforcing it.
If something tries to cross that boundary, it doesn't quietly succeed and hope someone catches the mistake later. The system stops it.
That's a very different philosophy from "Please remember to do this correctly."
We're all human. Eventually someone won't.
Good architecture assumes that.
It takes important rules out of people's heads and puts them into the structure of the system.
The goal isn't to eliminate mistakes. That's impossible. The goal is to make entire categories of mistakes hard to make accidentally.
And this is where all of it starts to compound.
- 1The first time you solve a problem, you build the solution.
- 2The next time, you reuse it.
- 3Eventually, the solution becomes a boundary.
- 4Then every new piece of software built inside that boundary inherits the decision automatically.
The architecture gets smarter without getting more complicated.
This is why I think creating something new should make creating the next thing easier. Not because we're writing less code, but because we're making fewer decisions. And the decisions we do make are increasingly deliberate.
That's the part of architecture I find beautiful.
You're not just building software. You're building the constraints that future software will be built inside.
You are deciding where complexity is allowed to exist, where it is encapsulated, and where it is simply not allowed to leak.
- You trade some freedom for consistency.
- Some possibilities for predictability.
- Some short-term convenience for long-term leverage.
And if you get those constraints right, something wonderful happens:
the system starts helping you build the system.
That's the kind of architecture I want to build.
Not architecture that makes software theoretically capable of anything. Architecture that makes the right things easy, the wrong things difficult, and the next thing easier than the last.