Architectural Patterns#

Architectural patterns are proven structural templates for organizing software systems. Each pattern makes different tradeoffs between complexity, scalability, flexibility, and maintainability. Choosing the right one depends on your constraints and quality attributes.

Layered Architecture#

The most common pattern — organizes code into horizontal layers with strict dependency rules:

┌─────────────────────────────┐
│   Presentation Layer        │  UI, API endpoints
├─────────────────────────────┤
│   Business Logic Layer      │  Domain rules, workflows
├─────────────────────────────┤
│   Persistence Layer         │  Data access, repositories
├─────────────────────────────┤
│   Database Layer            │  Storage engines
└─────────────────────────────┘
     Dependencies flow DOWN only

Sinkhole Anti-Pattern#

When requests pass through layers without adding value — just forwarding calls. If > 20% of requests are sinkholes, the architecture is over-layered.

Pipe-and-Filter#

Data flows through a pipeline of independent processing stages:

Input → [Filter A] → [Filter B] → [Filter C] → Output
              │             │             │
         Transform      Validate       Enrich

Example: Data Pipeline#

Raw CSV → [Parse] → [Validate] → [Transform] → [Enrich] → [Load to DB]
                         │
                    [Error Queue]

Variants#

Broker Pattern#

A central broker mediates communication between decoupled components:

┌──────────┐     ┌──────────┐     ┌──────────┐
│ Producer │────→│  Broker  │────→│ Consumer │
└──────────┘     │(mediator)│     └──────────┘
┌──────────┐     │          │     ┌──────────┐
│ Producer │────→│          │────→│ Consumer │
└──────────┘     └──────────┘     └──────────┘

Implementations#

Peer-to-Peer#

All nodes are equal — each can be both client and server:

    ┌───┐     ┌───┐
    │ A │─────│ B │
    └─┬─┘     └─┬─┘
      │    ╲    │
      │     ╲   │
    ┌─┴─┐   ┌┴──┐
    │ C │───│ D │
    └───┘   └───┘

P2P Variants#

Space-Based Architecture#

Designed for extreme scalability by eliminating the database as a bottleneck:

┌────────────────────────────────────────────────┐
│              Virtualized Middleware             │
│  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐     │
│  │ PU 1 │  │ PU 2 │  │ PU 3 │  │ PU N │     │
│  │      │  │      │  │      │  │      │     │
│  │ App  │  │ App  │  │ App  │  │ App  │     │
│  │ Cache │  │ Cache │  │ Cache │  │ Cache │     │
│  └──────┘  └──────┘  └──────┘  └──────┘     │
│         ↕ Data Replication Grid ↕              │
├────────────────────────────────────────────────┤
│  Messaging Grid │ Data Grid │ Processing Grid  │
├────────────────────────────────────────────────┤
│         Async Database Write-Behind            │
│                    ┌────┐                      │
│                    │ DB │                      │
│                    └────┘                      │
└────────────────────────────────────────────────┘

Key Components#

Serverless Architecture#

Functions execute in response to events — no server management:

┌──────────┐     ┌───────────────┐     ┌──────────┐
│  Event   │────→│   Function    │────→│  Output  │
│ (trigger)│     │ (ephemeral)   │     │ (storage)│
└──────────┘     └───────────────┘     └──────────┘

Events: HTTP request, queue message, file upload, schedule

Serverless Patterns#

Limitations#

Pattern Comparison#

Decision Matrix#

Combining Patterns#

Real systems combine patterns. A modern e-commerce platform might use:

• Layered within each microservice
• Broker (Kafka) between services
• Serverless for event-driven background tasks
• Pipe-and-filter for data ingestion
• Space-based for the checkout during flash sales

The art is knowing which pattern solves which problem at which level of the system.

Key Takeaways#

1. No pattern is universally best — each optimizes for different quality attributes.
2. Layered architecture is the safe default for simple applications but resists scaling.
3. Pipe-and-filter excels for data processing; think Unix philosophy.
4. Broker decouples producers from consumers but introduces a SPOF.
5. Space-based solves extreme scale but at extreme complexity and cost.
6. Serverless minimizes operations but introduces cold starts and vendor lock-in.
7. Real systems combine patterns at different levels — choose per component, not per system.