Architectural Patterns

This article is a concept explanation of architectural patterns – including exam questions, examples, and tags.

In a Nutshell

Architectural patterns are reusable solution structures at the system level. They describe context, forces, solution, and consequences – with a focus on quality goals such as maintainability, scalability, security, and testability.

Concise Technical Description

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

Important trade-offs:

• Consistency vs. availability
• Synchronous RPC chains vs. asynchronous messaging
• Central database vs. data per service

Modern systems combine patterns (e.g., DDD boundaries + hexagonal per service). Exam-relevant topics are definition, consequences, deployment scenarios, and risks (e.g., distributed monolith).

Exam-Relevant Key Points

• Differences and consequences of monolith/microservices
• Layered architecture + dependency inversion
• Ports & adapters (hexagonal)
• IHK: Name quality goals + metrics (MTTR, latency)
• Security: zero trust, secrets, service-to-service auth
• Economics: operational/license costs, team boundaries
• Documentation: C4 (L1–L3) + ADRs

Core Components

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

Practical Example (hexagonal, heavily simplified)

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

Advantages and Disadvantages

Advantages

• Better changeability
• Testability
• Targeted quality attributes

Disadvantages

• More complexity
• Infrastructure/observability required
• Risk of distributed monolith

Typical Exam Questions (with Brief Answer)

1. When is layered architecture sensible? With clear responsibilities; dependencies pointing inward.
2. Microservices vs. monolith: core difference? Deployment/data storage/transactions.
3. What does hexagonal architecture provide? Separates core logic from inputs/outputs via ports/adapters.

Free Response

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

Learning Strategy

1. Sketch C4 for a system.
2. Mark sync/async paths per use case.
3. Practice short definitions + trade-offs.
4. Name risks and countermeasures.

Further Information

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