Architectural Patterns

This post is a concept explainer for architectural patterns — including exam questions, examples, and key takeaways.

In a Nutshell

Architectural patterns are reusable solution structures at the system level. They describe context, forces, solution, and consequences—focusing on quality attributes like maintainability, scalability, security, and testability.

Core Definition

An architectural pattern defines the overall system structure (layers, ports & adapters, microservices, event flows) and influences quality attributes.

Common trade-offs include:

• Consistency versus availability
• Synchronous RPC chains versus asynchronous messaging
• Centralized database versus per-service data stores

Modern systems combine patterns (for example, DDD boundaries plus hexagonal architecture per service). Exam-relevant topics cover definitions, consequences, use case scenarios, and risks such as the distributed monolith antipattern.

Key Exam Topics

• Monolith and microservices: differences and consequences
• Layered architecture with dependency inversion
• Ports & adapters (hexagonal)
• IHK: naming quality goals and metrics (MTTR, latency)
• Security: zero trust, secrets management, service-to-service auth
• Economics: operational costs, licensing, team boundaries
• Documentation: C4 (L1–L3) and ADRs

Core Components

1. Context and assumptions
2. Problem and forces
3. Structure and building blocks
4. Communication style (sync/async)
5. Data strategy
6. Interfaces and protocols
7. Build, test, deploy, and observability
8. Architectural elements (layers, adapters)
9. Security (authentication, authorization, isolation)
10. Testing (contract and chaos)

Practical Example (Hexagonal, Simplified)

Domain: Order.confirm() emits domain event
Application service orchestrates use case
Ports define contracts (repository, message bus)
Adapters couple REST, SQL, Kafka

Strengths and Weaknesses

Strengths

• Better changeability
• Improved testability
• Targeted quality attributes

Weaknesses

• Added complexity
• Infrastructure and observability required
• Risk of distributed monolith

Common Exam Questions (with Brief Answers)

1. When is layered architecture appropriate? When responsibilities are clear and dependencies flow inward.
2. Microservices versus monolith: what’s the core difference? Deployment independence, data ownership, and transaction scope.
3. What does hexagonal architecture achieve? It isolates core logic from inputs and outputs through ports and adapters.

Free-Form Study

Learn patterns through problem, forces, solution, and consequences. Document architecture decisions as ADRs and visualize with C4.

Study Strategy

1. Sketch a C4 diagram for a system.
2. Mark sync and async paths per use case.
3. Practice short definitions and trade-offs.
4. Identify risks and mitigation strategies.

Further Reading

1. https://microservices.io/patterns
2. https://c4model.com/
3. https://martinfowler.com/architecture