A technically sound design can still be the wrong design

Too much architecture is not necessarily bad architecture. Every component may be well chosen and correctly implemented, while the architecture as a whole is still a poor fit for what the organization actually needs.

A platform capable of serving millions of users offers little practical advantage when the application is likely to serve only a few hundred. Especially when that unused capability introduces additional cost, operational work and dependencies every day.

Technical sophistication is valuable only when it serves a purpose.

Every possibility has a price

Architecture is often justified with the words: “Then we will be able to…”

Being able to scale, fail over, expand or accommodate future uses may certainly be valuable. But flexibility, scalability and redundancy are not free. They can introduce:

  • higher infrastructure costs;
  • more components and dependencies;
  • additional knowledge that must remain available;
  • more monitoring, maintenance and patching;
  • more ways in which the system can behave unexpectedly;
  • a longer path from a proposed change to production.

The full cost of architectural complexity therefore does not appear on the cloud bill alone.

Design for plausible growth

A suitable design does not ignore the future. It distinguishes between:

  • what is needed now;
  • what can reasonably be expected;
  • what is possible but remains unlikely for the foreseeable future.

The objective is not to build every potential future capability today. It is to meet present requirements without making the probable next steps unnecessarily difficult.

That leaves room for growth without requiring the organization to carry the cost and complexity of that growth before it occurs.

Reversibility can be more valuable than preparation

Not every future decision needs to be made in advance.

A simple solution that can be replaced or expanded later may be more valuable than an elaborate platform designed from day one to support every imaginable scenario.

This changes the questions an architect should ask:

  • Can this be expanded later without rebuilding everything?
  • Which decisions would be difficult or expensive to reverse?
  • Which complexity can safely be postponed?
  • How will we know when the simpler solution is no longer sufficient?

A reversible decision preserves options. Premature complexity commits resources before the need has been demonstrated.

Complexity should have a demonstrable purpose

Every significant component in an architecture should have a clear reason for being there.

If we removed this, which business requirement would no longer be met?

If there is no concrete answer, the component may have been included for an abstract future rather than an actual need.

That does not automatically mean it should be removed. It means its cost, operational burden and dependencies deserve another look.

Designing too little is also possible

The opposite mistake exists as well.

A cheap and simple design may be unsuitable when failure has serious consequences, growth is predictable, security requirements are demanding or regulatory and operational obligations require additional controls.

The objective is therefore not the simplest possible architecture. It is:

The least complex architecture that responsibly meets the requirements.

The word responsibly matters. Simplicity should remove unnecessary complexity, not conceal necessary work or transfer unacceptable risks to the future.

Good architecture fits

The quality of an architecture is not determined by the number of modern services, diagrams or automation layers it contains.

A good design:

  • supports what the organization needs to accomplish;
  • fits its scale and plausible development;
  • can be understood and operated by the people responsible for it;
  • manages the risks that genuinely matter;
  • introduces complexity only when that complexity provides demonstrable value.

The best architecture is not the one capable of doing the most. It is the one that does enough, remains understandable and can grow responsibly when the need arises.

About the author

Harold Snippe

Harold Snippe is the founder of CS Infostructure. His experience spans building hosting and network infrastructure, operating international internet platforms and more than ten years of platform and security work within large banking environments.

About Harold and his background →

Questions, corrections and contributions

Talk to Harold

Have a question, a different experience or something that would make this article more useful? Leave a thought. Your feedback may help improve this page.

← Back to the Library