Recently I’ve been watching a lot of content about architecture. Not software architecture, but actual buildings. There’s something about the way physical structures are designed and constructed that resonates deeply with how I think about software engineering.
Architecture, at its essence, is about crafting spaces where people can live, work, and connect. A building might be visually stunning or elegantly simple, but its true success lies in its livability. If it cannot be inhabited, it has missed its purpose. It might qualify as art, but it ceases to be architecture.
Engineering isn’t so different It’s easy to get caught up in abstractions, patterns, and the excitement of creating. We often fall in love with the craft: the cleverness of a design, the precision of an implementation, the elegance of the code. But elegance without purpose is just ornamentation. What we build isn’t meant to be admired from afar; it’s meant to be used, trusted, and integrated into people’s lives.
We create products through software, not the other way around. Our role isn’t to make technology fascinating — it’s to make it practical, reliable, and impactful. A system that’s technically impressive but disconnected from its purpose is like a museum exhibit: it might be admired, but it cannot be lived in.
That’s why true ownership begins long before the first commit, or even before the first line of code is written. It starts with understanding the problem, questioning the assumptions, and ensuring that what we’re building is worth building. Code may be the most visible part of the system, but clarity and purpose form the foundation that holds everything together.
And just like in architecture, we don’t build in isolation. Collaboration with design, product, and business teams is essential. Each perspective contributes to shaping a structure that is not only functional but also resilient and aligned with its purpose.
Over time, this mindset brings clarity to what engineering truly entails. It’s not about invention for the sake of novelty. It’s about creating something that earns its place, something people can rely on without ever needing to understand its inner workings.
Maybe that’s why I find myself drawn to architecture, especially brutalism.
There’s an honesty in its raw concrete, unadorned surfaces, and exposed structures. Brutalism doesn’t seek approval or admiration. It exists to fulfill its purpose, which is to provide shelter, stability, and longevity. And in that steady commitment to function, it reveals a quiet, understated beauty.
Brutalist buildings often evoke strong emotions, but their appeal is incidental, not intentional. Their beauty lies in their authenticity: every element has a purpose, and nothing is superfluous.
Good software shares the same essence.
It doesn’t rely on decoration or fleeting trends. Instead, it is purposeful, straightforward, and honest about its intent. If beauty emerges, it’s a byproduct of its authenticity, not a deliberate attempt to dazzle.
We don’t create to impress. We create to be used.
Code is merely the framework; the product is the structure it supports.
The finest architecture — whether physical or digital — is the kind that quietly fulfills its purpose, enduring long after its creator has stepped away.