15 Universal Software Architecture Principles and Key Design Guidelines

Designing a good architecture is not a formulaic task; it relies on the architect's insights, trade‑offs, and experience, guided by established principles that help meet system requirements.

1. Forming Architecture Principles

The process of establishing principles is illustrated in the diagram below.

Architecture principles should be SMART

2. Fifteen Universal Architecture Principles

Based on the book *The Architecture Bible*, the following principles are widely applicable:

1) N+1 Design : Ensure at least one redundant instance exists for every service to survive failures.

2) Rollback Design : Provide mechanisms to revert to a previous stable version within a reasonable time frame.

3) Disable Design : Include feature switches that can turn off risky functionality to buy time for fixes.

4) Monitoring Design : Incorporate monitoring from the design phase to enable self‑diagnosis, self‑repair, capacity planning, and bottleneck detection.

5) Multi‑Active Data Center Design : Avoid single‑point data‑center reliance; consider read/write separation and shared data structures.

6) Adopt Mature Technologies : Prefer proven technologies for critical components; experiment with new tech only in low‑risk areas.

7) Fault Isolation : Prevent a single business or hardware failure from affecting the entire system.

8) Horizontal Scaling : Expand capacity by adding hardware (X‑axis), splitting databases (Y‑axis), or partitioning functionality (Z‑axis).

9) Buy Non‑Core Components : Outsource or purchase functionality that does not provide a competitive advantage.

10) Use Commodity Hardware : Favor low‑cost, interchangeable hardware to keep total cost lower than high‑end alternatives.

11) Rapid Iteration : Employ small builds and releases to reduce failure impact and accelerate feedback loops.

12) Asynchronous Design : Avoid synchronous dependencies that can cause cascading failures and performance bottlenecks.

13) Stateless Design : Keep components stateless to improve scalability and load balancing.

14) Forward‑Looking Design : Plan for the current system (Now), the next generation (Now+1), and future generations (Now+2).

15) Automation : Automate design and build processes to eliminate human error.

3. Core Design Principles

A good design should:

1) Solve existing needs and problems.

2) Balance realistic schedule and risk.

3) Anticipate future requirements without over‑designing, allowing evolution through iterations.

Separation of Concerns : Divide the system into loosely coupled, highly cohesive modules.

Single Responsibility : Each component should have one clear purpose.

Least Knowledge (Law of Demeter) : Components should know as little as possible about others' internal details.

Don’t Repeat Yourself (DRY) : Define functionality in a single place.

Minimal Up‑Front Design : Design only what is necessary; avoid excessive upfront planning, especially for unclear requirements.

Low Coupling, High Cohesion : Use interfaces and adapters to prevent mutation and keep concerns separate.

Non‑Intrusive Architecture : Prefer components or frameworks that can be integrated without forcing the entire system to conform to a specific technology stack.

By adhering to these principles, architects can create cost‑effective, highly available, and scalable systems.

Source: https://blog.csdn.net/hguisu/article/details/78259898