Ask ten engineers to define software architecture and you will get ten answers. That ambiguity is not academic. Teams that cannot agree on what architecture is end up litigating the wrong debates, treating framework selection as architecture and load-bearing structural choices as mere 'implementation detail'.

Architecture is the set of decisions that are hard to change later. Getting the definition right tells you where to spend scarce senior attention: the choices that, if wrong, are expensive to reverse.

Richards and Ford define architecture as the union of four interlocking dimensions.

Structure is the type of architecture style(s) the system is built from — layered, microservices, event-driven and so on. Structure alone is not the whole picture.

Architecture characteristics are the system's success criteria orthogonal to what it does — the -ilities such as availability, scalability, and fault tolerance.

Architecture decisions are the rules of the road: they constrain how the system may be built (for example, 'only the business layer may access the database').

Design principles are guidelines rather than hard rules — for example, 'prefer asynchronous messaging between services to improve performance'. A principle bends where a decision does not.

A team is asked to 'redesign the checkout'. Splitting by the four dimensions clarifies the work.

Structure: move checkout from the shared monolith into its own service. Characteristics: the driver is elasticity — checkout must absorb flash-sale spikes. Decisions: payment logic must never call the inventory database directly; it goes through the inventory service's API. Principles: prefer eventual consistency for the order-confirmation email.

Notice that only structure is about boxes and lines. The other three are what make the boxes correct — and they are exactly the parts a junior 'redesign' usually omits.

The four dimensions map onto the rest of the discipline. Characteristics (dimension two) get their own deep study; patterns and styles are dimension one; and the discipline of choosing between decisions and principles under uncertainty is architectural thinking.

Crucially, architecture is distinguished from design by reversibility. Design decisions — a class name, a screen layout — are cheap to change. Architecture decisions ripple across the system. The blurry line between the two is exactly where architects earn their keep.