Archetypes

Software architecture decision-making and implementation guidance across 14 architectural paradigms.

• Orchestrator: Use Skill(architecture-paradigms) to select a paradigm.
• Comparison: See Quick Reference Matrix.
• Learning: Follow Learning Paths.

Paradigms

Core Architectural Patterns

• Layered Architecture: Traditional N-tier separation of concerns.
• Hexagonal (Ports & Adapters): Infrastructure independence and flexibility.
• Functional Core, Imperative Shell: Business logic isolation for testability.

Distributed Systems

• Microservices: Independent business capability services.
• Service-Based Architecture: Coarse-grained services (SOA-lite).
• Event-Driven Architecture: Asynchronous, decoupled communication.
• CQRS + Event Sourcing: Command/query separation with audit trails.

Specialized Patterns

• Modular Monolith: Single deployable with strong internal boundaries.
• Serverless: Function-as-a-Service systems.
• Space-Based: In-memory data grids for linear scalability.
• Pipeline: Processing stages for ETL workflows.
• Microkernel: Plugin architecture for extensible platforms.
• Client-Server: Traditional centralized or P2P systems.

Learning Paths

1. Architecture Fundamentals (Beginner)

Duration: 2-3 weeks Goal: Learn basic architectural concepts and patterns.

1. Start: architecture-paradigms (overview and selection).
2. Core: Study architecture-paradigm-layered (fundamental pattern).
3. Progress: Learn architecture-paradigm-functional-core (testability principles).
4. Practice: Apply layered architecture to a simple project.

Skills Covered: Layered, Functional Core, basic architecture principles.

2. Modern Architecture Patterns (Intermediate)

Duration: 3-4 weeks Goal: Learn contemporary architectural approaches.

1. Foundation: Complete Architecture Fundamentals path.
2. Flexibility: Study architecture-paradigm-hexagonal (infrastructure independence).
3. Evolution: Learn architecture-paradigm-modular-monolith (strong boundaries).
4. Integration: Practice combining paradigms in a single system.

Skills Covered: Hexagonal, Modular Monolith, paradigm combination.

3. Distributed Systems Architecture (Advanced)

Duration: 4-6 weeks Goal: Design and implement distributed architectures.

1. Prerequisites: Complete Modern Architecture Patterns path.
2. Distributed Basics: Study architecture-paradigm-microservices (independent services).
3. Communication: Learn architecture-paradigm-event-driven (asynchronous systems).
4. Advanced: Learn architecture-paradigm-cqrs-es (complex collaboration domains).
5. Specialization: Choose serverless, space-based, or service-based patterns.

Skills Covered: Microservices, Event-Driven, CQRS/ES, specialized patterns.

4. Domain-Specific Architecture (Specialized)

Duration: 2-3 weeks each Goal: Gain expertise in specific architectural domains.

Real-time & Streaming Systems

• Primary: Event-Driven Architecture.
• Secondary: Space-Based Architecture.
• Tertiary: Pipeline Architecture.
• Use Case: IoT, financial trading, logistics platforms.

High-Throughput Web Applications

• Primary: Microservices.
• Secondary: Serverless.
• Tertiary: CQRS/ES.
• Use Case: Social media, e-commerce, content platforms.

Enterprise Integration

• Primary: Service-Based Architecture.
• Secondary: Hexagonal Architecture.
• Tertiary: Modular Monolith.
• Use Case: ERP systems, banking, legacy modernization.

Extensible Platforms

• Primary: Microkernel Architecture.
• Secondary: Plugin-based design patterns.
• Use Case: IDEs, marketplaces, integration platforms.

Quick Reference Matrix

Paradigm Evolution Path

Typical Architecture Evolution Journey

Startups often begin with a Layered Architecture. As the team grows to 10-50 engineers, a Modular Monolith helps manage complexity. Scaling to 50-200 engineers typically necessitates a move to Microservices or a Service-Based architecture. At maturity (200+ engineers), systems often evolve into Event-Driven architectures combined with specialized patterns.

Common Migration Paths

Migration from a monolith to a distributed system generally moves from Layered to Modular Monolith, then to Microservices, and finally to Event-Driven. Increasing complexity drives evolution from Layered to Hexagonal, then Functional Core, and potentially CQRS/ES. Cloud-native transitions typically progress from Layered to Modular Monolith, then to Serverless or Event-Driven architectures.

Architecture Decision Triggers

Scale Triggers (When to evolve architecture):

• Team size crosses threshold (5, 15, 50, 200 engineers).
• Deployment frequency needs increase.
• Independent scaling requirements emerge.
• Geographic distribution becomes necessary.

Complexity Triggers (When to adopt patterns):

• Business rules become complex (Functional Core).
• Integration points increase (Hexagonal).
• Real-time requirements emerge (Event-Driven).
• Audit/compliance needs arise (CQRS/ES).

Technology Triggers (When to change patterns):

• Framework migration needed (Hexagonal).
• Cloud migration planned (Serverless/Microservices).