Software Architecture Patterns Reference Guide
A concise guide to core software architecture principles, patterns, and examples.
Architecture-Centred Approach
Architecture design represents system-wide strategic decisions. It ensures that core
system structure, non-functional requirements, and long-term maintainability are
addressed. Architectural design focuses on patterns, organization, and high-level
responsibilities that shape the system’s behavior.
Key Ideas
• Avoid reinventing the wheel — reuse existing solutions and frameworks.
• Architecture captures big ideas: motivations, constraints, and system-wide structures.
• Design patterns handle local design decisions, while architectural patterns shape overall
system structure.
• Architecture visualizations communicate design intent to stakeholders.
Key Architectural Patterns
Model-View-Controller (MVC)
Separates application logic, UI, and data. The Model manages data, the View presents it,
and the Controller handles input.
Example: Used in frameworks like Django, Ruby on Rails, and Angular — where views
update automatically when model data changes.
Layered Architecture
Organizes the system into layers where each layer only communicates with the one below
it.
Example: Used in enterprise applications where the presentation layer, business logic
layer, and data access layer are distinct.
Repository Pattern
Provides a central place for data access logic, acting as an intermediary between business
logic and the database.
Example: Used in .NET applications to separate database queries from domain logic.
Client-Server Architecture
Divides the system into clients (which request services) and servers (which provide
services).
Example: Used in web applications — browsers act as clients, and web servers deliver
requested data.
Pipe and Filter Architecture
Processes data through a sequence of processing elements (filters) connected by pipes.
Example: Used in data streaming systems and Unix pipelines, where each filter performs
a specific operation.
Application Architectures
Data Processing Applications
Handle large batches of data without user interaction during processing. Typical pattern:
Input → Process → Output.
Example: Used in payroll systems or billing systems where data is processed in
scheduled batches.
Transaction Processing Applications
Process user requests and update databases in real time, ensuring data consistency and
reliability.
Example: Used in e-commerce, banking, or airline reservation systems.
Event Processing Systems
React to events from the system’s environment in real time.
Example: Used in gaming engines, real-time analytics, or IoT monitoring systems.
Language Processing Systems
Interpret or compile formal languages defined by user input.
Example: Used in compilers, interpreters, or command-line shells.
Realising Non-Functional Requirements
Architectural choices greatly influence system performance, security, safety, and
maintainability.
• Performance — Centralize critical steps and minimize communication between
components.
• Security — Use layered architecture to isolate critical components.
• Safety — Contain safety-critical logic in isolated subsystems.
• Availability — Introduce redundancy and fault-tolerance mechanisms.
• Maintainability — Favor fine-grained, replaceable components and avoid global data
structures.
Visual Illustrations
Simplified color sketches showing how each architectural pattern organizes system
components.
MVC
Layered
Repository
Client-Server
Pipe and Filter