Fundamentals 5 min read

Software Architecture Design: Basic Concepts, Sources of Complexity, Three Principles, and Design Process

This article explains the purpose of software architecture design, identifies sources of complexity such as performance, availability and scalability, outlines three guiding principles—appropriateness, simplicity, and evolution—and presents a practical step‑by‑step design process illustrated with diagrams.

Java Captain
Java Captain
Java Captain
Software Architecture Design: Basic Concepts, Sources of Complexity, Three Principles, and Design Process

The purpose of architecture design is to address system complexity, not to achieve every possible quality attribute; instead, designers should identify real business challenges and solve them in a targeted manner, balancing effort and benefit.

Complexity in architecture stems from several dimensions:

High Performance

High Availability

Scalability

Low Cost, Security, Scale

The three guiding principles of architecture design are:

Appropriateness Principle

Good architectures are created within the constraints of current resources, personnel, and business needs, delivering maximum effect without over‑engineering; copying large‑company solutions without context often leads to failure.

Simplicity Principle

When both simple and complex solutions satisfy requirements, the simpler one should be chosen, following the KISS (Keep It Simple, Stupid!) philosophy.

Evolution Principle

Software systems must evolve with business changes; attempting to design a static, all‑encompassing architecture is unrealistic. Architects should avoid the trap of “one‑shot” designs and instead embrace incremental evolution.

Practical advice includes:

Design an architecture that meets current business needs.

Iteratively refine the architecture, preserving good designs and discarding flawed ones.

When business changes, extend, refactor, or even rewrite the architecture while retaining valuable lessons and logic.

The typical architecture design process is illustrated in the following diagram:

Source: juejin.im/post/5b2c6669e51d4558c91ba776

Software ArchitectureProcesscomplexitydesign principlessimplicityevolution
Java Captain
Written by

Java Captain

Focused on Java technologies: SSM, the Spring ecosystem, microservices, MySQL, MyCat, clustering, distributed systems, middleware, Linux, networking, multithreading; occasionally covers DevOps tools like Jenkins, Nexus, Docker, ELK; shares practical tech insights and is dedicated to full‑stack Java development.

0 followers
Reader feedback

How this landed with the community

login Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.