High-level essays that distinguish architecture from design and discuss how architectural decisions shape a system's structure and qualities.
Explains core architecture concepts, responsibilities of an architect, and how architecture guides detailed design and implementation.
Introduces ports-and-adapters (hexagonal) architecture and how it isolates domain logic from external concerns like UI and databases.
Compares layered, hexagonal, and clean architectures with practical guidance on choosing an approach for your application.
Surveys traditional layered architectures and more modern variations for .NET and web applications.
Defines microservices, their benefits, and trade-offs, and explains when they are appropriate compared to a monolithic architecture.
Argues for starting with a well-structured monolith and moving to microservices only when there are clear scaling or organizational drivers.
Provides an overview of microservices characteristics, scenarios where they work well, and common pitfalls.
Introduces the core ideas of DDD, including ubiquitous language, bounded contexts, and focusing on complex business domains.
A collection of articles discussing strategic and tactical DDD patterns, context mapping, and aggregates.
Shows how to apply DDD concepts when designing microservices, including aggregate roots and bounded contexts.
Describes principles and best practices for building scalable, high-performance cloud systems on AWS.
Covers patterns like horizontal scaling, partitioning, and caching to support growth in load and data volume.
A set of practices for building cloud-native apps that scale easily and can be deployed reliably.
Explains patterns such as retries, timeouts, circuit breakers, and bulkheads to keep systems responsive under failure.
Discusses how distributed systems introduce failure modes and the patterns needed to tolerate them.
Deep dives from Amazon engineers on building and operating highly available, resilient services at scale.
Clarifies different meanings of event-driven architecture and when event streams are a good fit.
Describes event-driven applications, their benefits for decoupling and scalability, and typical implementation patterns.
Explains Kafka's core concepts as a backbone for event streaming and event-driven microservices.
Compares synchronous HTTP APIs, queues, and publish/subscribe systems and when each is appropriate.
Describes patterns that help manage latency, back pressure, and coupling in distributed communication.
Shows how asynchronous messaging and queues can improve reliability and scalability for cloud-native systems.
Articles that explain foundational object-oriented and architectural design principles used in modern systems.
Summarizes principles such as loose coupling, high cohesion, and autonomy for cloud-based solutions.
Practical explanations and examples of the SOLID design principles applied to maintainable codebases.
Discusses logging, metrics, and tracing patterns for observing distributed systems behavior.
Provides guidance on centralizing logs, metrics, and traces as shared infrastructure services.
The core specification for delegated authorization used to secure APIs and web applications.
Proposes a simple set of diagrams (context, container, component, and code) to communicate architecture clearly.
Describes a lightweight format for recording important architectural decisions and their context over time.
Articles covering how much documentation is “enough” and how to keep diagrams and docs useful as systems evolve.
Describes a pattern for incrementally replacing legacy systems by routing traffic to new components over time.
Classic book site that explains systematic refactoring techniques and when to use them safely.
Explores architectures that support continuous change using fitness functions and incremental evolution.
Defines 12 principles for SaaS apps that are easy to deploy, scale, and maintain in the cloud.
Explains what cloud-native means in practice, including containers, orchestration, and DevOps practices.
Shows how microservices, containers, and serverless building blocks support cloud-native architectures.
Discusses why each service should own its data and how to avoid overly coupled shared databases.
Shows how to use DDD concepts to define service boundaries and data ownership in microservice architectures.
Explains how event streams can synchronize data across bounded contexts without tight coupling.
Reflects on balancing emergent design from agile practices with intentional upfront architectural thinking.
Introduces evolutionary architecture and fitness functions as a way to guide change instead of rigid big upfront design.
Explains the “You Aren't Gonna Need It” principle and how to avoid speculative architecture that doesn't serve today's needs.