Monoliths to cells: structural, integration, data and resilience patterns with Java examples, trade-offs and when not to use them.
Monolithic Architecture: A single deployable unit containing all functionality. When it is the right answer, how monoliths degrade, and how to keep one healthy.
Modular Monolith: One deployable with strongly enforced module boundaries, private data per module and in-process events, giving most of the benefits of microservices without the distributed-systems cost.
Microservices Architecture: Independently deployable services organized around business capabilities, each owning its data. Benefits, real costs, sizing, communication and the prerequisites teams often skip.
Event-Driven Architecture Pattern: Broker and mediator topologies, event notification vs event-carried state transfer, Java implementation with Kafka, and design rules for events as contracts.
Serverless Architecture: Functions and managed services that scale to zero and bill per use, with cold starts, limits, state handling and cost crossover points explained.
Cell-Based Architecture: Partitioning a system into independent, self-contained cells that each serve a subset of customers, so failures and bad deployments affect only one cell.
Multi-Tenant Architecture: Silo, bridge and pool isolation models, tenant context propagation, noisy-neighbour controls and tenant-aware operations for SaaS.
Headless Architecture: Decoupling the presentation layer from back-end capabilities exposed as APIs, as in headless commerce and headless CMS, with composable (MACH) architectures.
API-Led Architecture: Organizing integration into system, process and experience APIs to decouple consumers from systems of record, with governance and reuse metrics.
Hexagonal Architecture (Ports and Adapters): Isolating domain logic from frameworks and infrastructure with ports and adapters, so the core can be tested and evolved independently of databases, APIs and messaging.
Clean Architecture: Robert C. Martin's concentric layers with the dependency rule pointing inward; how it relates to hexagonal and onion architectures and how to apply it pragmatically.
Domain-Driven Design (DDD): Strategic DDD (bounded contexts, context maps, subdomains) and tactical DDD (aggregates, entities, value objects, domain events), and how DDD drives service boundaries.
CQRS and Event Sourcing: Separating write and read models, storing state as a sequence of events, projections and snapshots, and why the two patterns are often combined but should be adopted carefully.
Saga Pattern: Managing long-running business transactions across services with local transactions and compensations, comparing orchestration and choreography with a Java/Temporal example.
Strangler Fig Pattern: Incrementally replacing a legacy system by routing functionality piece by piece to new components, with data synchronization strategies and decommissioning criteria.
Backend for Frontend (BFF): A dedicated backend per client experience that aggregates and shapes APIs, owned by the front-end team, with guidance on when GraphQL federation is a better fit.
Circuit Breaker: Failing fast when a dependency is unhealthy, the closed/open/half-open state machine, tuning thresholds, fallbacks and Resilience4j configuration.
Bulkhead Pattern: Isolating resources (thread pools, connection pools, instances, cells) so that one failing dependency or tenant cannot exhaust capacity for everything else.
Retry and Timeout Patterns: Setting timeouts and deadlines, retrying safely with exponential backoff and jitter, retry budgets, idempotency and avoiding retry storms across layers.
Service Mesh: Moving service-to-service networking concerns (mTLS, retries, traffic shifting, telemetry) into an infrastructure layer of proxies, and when that complexity pays off.
Sidecar Pattern: Deploying a helper process alongside an application in the same pod to add capabilities such as proxies, log shipping, secrets or configuration without changing the app.
Zero-Trust Architecture: Never trust, always verify: identity-centric access, least privilege, micro-segmentation and continuous verification, based on NIST SP 800-207, applied to users, devices and workloads.