Software Architecture Fundamentals learning path: everything to study, topic by topic

Understanding the role of software architecture, the distinction between design and architecture, and how to reason about structure, behavior, and cross-cutting concerns at scale.

Organizing systems into horizontal layers (presentation, business logic, data access) with strict dependency rules between layers. Covers n-tier patterns, layer isolation, and when layering creates accidental complexity.

Decomposing systems into well-defined modules with clear responsibilities and boundaries. Covers module cohesion, package design principles, and the impact of modularity on maintainability and deployability.

Measuring and managing the degree of interdependence between components (coupling) and the functional relatedness within a component (cohesion). Covers afferent/efferent coupling, instability metrics, and the main sequence.

Defining component boundaries, responsibilities, and interfaces. Covers identifying components from domain requirements, shared kernel patterns, and the role of component design in enabling team autonomy.

Ports and adapters pattern that isolates core domain logic from external concerns like databases, UIs, and third-party services. Enables testability and framework independence.

Designing systems where components communicate through events. Covers event notification, event-carried state transfer, event sourcing, and the tradeoffs of eventual consistency and choreography vs orchestration.

Structuring an application as a collection of small, independently deployable services organized around business capabilities. Covers service decomposition, inter-service communication patterns, data isolation, and distributed systems tradeoffs.

Command Query Responsibility Segregation separates read and write models. Event Sourcing stores state as an immutable sequence of events. Covers projections, snapshotting, eventual consistency, and when these patterns add vs destroy value.

Designing a single deployable unit with strong internal module boundaries. Covers the modular monolith as a valid architectural choice, strangler fig pattern for decomposition, and anti-corruption layers for legacy integration.

Designing systems to handle increasing load without proportional cost increases. Covers horizontal vs vertical scaling, stateless design, sharding, caching strategies, and the relationship between scalability and cost.

Building systems that continue to function correctly in the presence of failures. Covers circuit breakers, bulkheads, retry strategies, graceful degradation, chaos engineering, and SLO/SLA/SLI frameworks.

Embedding security into system architecture through defense in depth, threat modeling, zero-trust principles, and secure-by-design patterns. Covers authentication/authorization architecture, secrets management, and data protection strategies.

Designing for latency and throughput targets at the architecture level. Covers performance budgets, caching hierarchies, asynchronous processing patterns, database query optimization at design time, and capacity planning.

Designing systems to be understandable from their external outputs. Covers structured logging, distributed tracing, metrics, the three pillars of observability, and alerting strategy that avoids alert fatigue.

Understanding the CAP theorem and its implications for distributed data stores. Covers consistency models (strong, eventual, causal), PACELC extension, and how to choose the right consistency level for a given use case.

Managing service-to-service communication in microservices with a dedicated infrastructure layer. Covers sidecar proxies, control plane vs data plane, mTLS, traffic management, and when a service mesh adds value versus adds complexity.

Using an API gateway as the single entry point for external clients. Covers gateway responsibilities (auth, rate limiting, routing, aggregation), backends-for-frontends (BFF) pattern, and gateway vs service mesh boundaries.

Managing data across service boundaries. Covers database-per-service, shared database anti-pattern, saga pattern for distributed transactions, data mesh concepts, and polyglot persistence.

Decoupling services through message brokers and async communication. Covers at-least-once vs exactly-once delivery, idempotency, message ordering, competing consumers, and the outbox pattern for reliable event publishing.

Documenting significant architectural decisions and their context, options considered, and consequences. Covers ADR format, when to write one, how to maintain an ADR log, and using ADRs to onboard new engineers.

Systematically evaluating architectural options against competing quality attribute requirements. Covers ATAM (Architecture Tradeoff Analysis Method), quality attribute scenarios, utility trees, and sensitivity/tradeoff points.

Defining automated tests that validate architectural characteristics over time. Covers structural fitness functions (dependency rules), process fitness functions (deployment pipeline gates), and holistic fitness functions for system-wide properties.

Designing systems that can change incrementally over time while preserving fitness. Covers guided change via fitness functions, incremental change patterns, architectural coupling and evolvability, and the relationship between modularity and evolvability.

Establishing processes and guardrails that guide architecture decisions across teams. Covers architecture review boards, lightweight governance models, architecture principles, tech radar, and avoiding governance becoming a bottleneck.

Defining and communicating the long-term technical direction that serves business goals. Covers platform thinking, build vs buy decisions, technology debt portfolio management, architecture vision documents, and aligning engineering investment to business strategy.