From Straw Hut to Skyscraper: The Evolution of Software Architecture

1. Introduction

Software architecture evolves with computing technology. The article explores its history from a simple “straw hut” to a “skyscraper”.

2. Prehistoric Era: Monolithic Architecture

2.1 Everything in One Piece

Monolithic architecture is likened to a straw hut: small scale, simple structure, all functionality under one roof. Early programs bundled UI, business logic, data processing, and file operations into a single executable running on one machine.

2.2 Pros and Cons

Advantages :

Simple development – a single developer can build end‑to‑end.

Simple deployment – the whole project is packaged as one unit.

Simple testing – no inter‑module dependencies.

Disadvantages :

Difficult to scale – only whole‑system scaling is possible.

Hard to maintain – changes affect the entire codebase.

Deployment risk – a failure in any module can bring down the whole system.

Technology lock‑in – adopting a new technology requires rewriting the whole system.

3. First Evolution: Three‑Tier Architecture

3.1 Layered Design

With the rise of web applications, the limitations of monoliths became apparent, prompting a layered approach.

┌─────────────────┐
│   Presentation  │  ← HTML/CSS/JavaScript
├─────────────────┤
│   Business Logic│  ← Java/Python/PHP
├─────────────────┤
│   Data Layer    │  ← MySQL/Oracle
└─────────────────┘

The analogy moves from a straw hut to a brick house: each layer has a specific responsibility and communicates through interfaces.

3.2 MVC Pattern

Model : data model and business logic.

View : user‑interface presentation.

Controller : request handling and response dispatch.

This pattern underlies many web frameworks and remains widely used.

4. Second Evolution: Distributed Architecture

4.1 Business Expansion

When user numbers grew from thousands to millions, feature sets expanded, and teams grew, a single “building” could no longer accommodate the load.

Solution: distribute the system.

4.2 From One Building to a Campus

Monolithic = one building; distributed = a campus of independent services such as commerce, order, payment, and user services, each built and operated separately yet interconnected.

This pattern is the precursor of Service‑Oriented Architecture (SOA).

4.3 Enterprise Service Bus (ESB)

In the SOA era, ESB acts as the “main road” between services, handling routing, transformation, and protocol conversion.

5. Third Evolution: Microservices Architecture

5.1 SOA Upgrade

SOA services are coarse‑grained; microservices are fine‑grained.

SOA relies on a central ESB; microservices favor decentralization.

Microservices characteristics:

Small and autonomous : each service does one thing and can be deployed independently.

Technology diversity : different services may use different stacks.

Fault isolation : failure of one service does not affect others.

On‑demand scaling : only the pressured service is scaled.

5.2 Conway’s Law

“Design systems are compelled to mirror the communication structure of the organization that builds them.”

The article notes that team size influences architecture; therefore microservices encourage small “two‑pizza” teams.

6. Fourth Evolution: Cloud‑Native Architecture

6.1 Cloud Adoption

Since the 2010s, cloud platforms such as AWS and Alibaba Cloud have reshaped development and deployment, giving rise to cloud‑native architecture.

6.2 CNCF‑Defined Characteristics

Containerization : package applications as containers for build‑once‑run‑anywhere.

Microservices : split services for independent deployment and scaling.

Service Mesh : move service‑to‑service communication management out of business code.

Declarative APIs : describe “what” instead of “how”.

6.3 Kubernetes as the Operating System

Kubernetes provides container orchestration, service discovery, load balancing, and automatic failure recovery, acting as the “operating system” for cloud‑native systems.

7. Fifth Evolution: Intelligent Architecture

7.1 AI‑Driven Operations

AIOps : AI‑powered automation for operations.

Intelligent recommendation : AI suggests architectural solutions.

Automated testing : AI generates test cases.

Code generation : AI assists programming.

7.2 Architecture as Code

Future trends treat architecture itself as code: describing architecture in source files, version‑controlling designs, and automating deployment and verification.

8. Timeline Summary

1960‑1980: Monolithic – integrated.

1990‑2000: Layered (MVC).

2000‑2010: Distributed – SOA, ESB.

2010‑2020: Microservices – small, autonomous.

2020‑present: Cloud‑native – containerization, automation.

9. Conclusion

There is no universally “best” architecture; the optimal choice matches project size and complexity. Small projects can stay monolithic, while large internet services often combine microservices with cloud‑native practices. The core driver of architectural evolution is the need to manage increasing business, organizational, and operational complexity.