archetypes

Model system responsibilities across clients, servers, and optional peer-to-peer nodes. Use when designing systems with clear client-server communication needs.

Employ space-based or data-grid architectures to scale high-traffic, stateful workloads across multiple nodes. Use when building high-scale systems with in-memory data grid patterns.

Apply Command Query Responsibility Segregation (CQRS) and Event Sourcing (ES) for collaboration-heavy domains that require strong auditability and independent scaling of reads and writes. Use when designing systems requiring audit trails, event replay, or separate read/write scaling.

Structure systems around asynchronous, event-based communication to decouple producers and consumers for improved scalability and resilience. Use when building loosely coupled systems with asynchronous message-based communication.

Employ the "Functional Core, Imperative Shell" pattern to isolate deterministic business logic from side-effecting code for superior testability. Use when designing systems where pure functions and immutable data improve testability.

Employ the Hexagonal (Ports & Adapters) pattern to decouple domain logic from infrastructure, maximizing flexibility and testability. Use when designing systems that need strong separation between business logic and external dependencies.

Use a Layered (or N-Tier) architecture to separate presentation, domain logic, and data access responsibilities within a system. Use when building traditional applications with clear separation of concerns.

Build a minimal, stable core system that loads plug-ins to provide feature variability and extensibility. Use when building extensible plugin-based systems.

Decompose systems into a suite of small, independently deployable services that are aligned to specific business capabilities. Use when building large-scale distributed systems with independent deployability.

Maintain a single deployable artifact while enforcing strong internal boundaries between modules. Use when building systems that need module boundaries without distributed complexity.

Compose processing stages using a pipes-and-filters model for ETL, media processing, or compiler-like workloads. Use when building data processing or transformation pipelines.

Build serverless, Function-as-a-Service (FaaS) systems for event-driven or operations-light workloads. Use when building event-driven applications with minimal infrastructure management.

Employ a coarse-grained, service-based architecture (a lighter form of SOA) when microservices are not yet necessary but modular deployment is required. Use when building coarse-grained service-oriented systems.

Interactive selector and implementation planner for architecture paradigms. Use when selecting or comparing architecture patterns for a new system.