Software Architecture Course

Lesson 1 • Quality Attributes and Trade-offs

Introduces the key quality attributes that drive architectural decisions. Students learn to reason about competing concerns such as performance and maintainability.

Lesson 2 • Architectural Drivers and Constraints

Covers business goals, technical constraints, and regulatory requirements as inputs to architecture. Students map drivers to design decisions.

Lesson 3 • Roles and Responsibilities of Architects

Maps the architect's duties across technical and organisational dimensions. Clarifies how architects collaborate with developers, product owners, and stakeholders.

Lesson 4 • What Software Architecture Is

Defines architecture as structure, behaviour, and decisions beyond code. Anchors all subsequent chapters in a shared conceptual baseline.

Lesson 1 • Capturing Architectural Decisions

Teaches Architecture Decision Records and lightweight documentation practices. Students create traceable records that survive team changes.

Lesson 2 • Architectural Thinking Patterns

Introduces decomposition, abstraction, and separation of concerns as core thinking tools. These patterns underpin every design technique covered later.

Lesson 3 • Evaluating Architectural Options

Applies structured comparison techniques to candidate architectures. Students weigh options against quality attributes and project constraints.

Lesson 4 • Managing Uncertainty and Risk

Addresses how architects handle incomplete information and technical risk early in projects. Students apply risk-driven design to reduce costly surprises.

Lesson 1 • Monolithic Architecture Variants

Rehabilitates the monolith as a valid architectural choice and examines modular monolith patterns. Students recognise when monoliths outperform distributed alternatives.

Lesson 2 • Serverless and Cell-Based Architectures

Introduces function-as-a-service and cell-based isolation as modern deployment styles. Students assess suitability for workload characteristics and failure isolation.

Lesson 3 • Layered and Tiered Architectures

Covers the classic layered style and its n-tier variants used in enterprise systems. Students apply layering rules and identify common violations.

Lesson 4 • Service-Oriented and Microservices Styles

Contrasts coarse-grained service orientation with fine-grained microservices decomposition. Students evaluate coupling, cohesion, and operational complexity.

Lesson 1 • SOLID Principles in Architecture

Applies SOLID principles at the component level beyond individual classes. Students refactor designs to reduce fragility and improve extensibility.

Lesson 2 • Component Versioning and Evolution

Addresses how components change over time without breaking consumers. Students apply semantic versioning and backward-compatibility strategies.

Lesson 3 • Cohesion and Coupling Principles

Defines cohesion and coupling metrics and their impact on changeability. Students measure and improve component boundaries using established heuristics.

Lesson 4 • Package and Module Organization

Covers strategies for grouping classes into packages and modules with clear ownership. Students apply package principles to control release and reuse granularity.

Lesson 1 • Resilience and Fault Tolerance Patterns

Teaches circuit breakers, retries, bulkheads, and timeouts for building resilient services. Students design failure-handling strategies that prevent cascading outages.

Lesson 2 • Distributed Data Management

Addresses data ownership, saga patterns, and eventual consistency in distributed transactions. Students design data flows that avoid distributed transaction pitfalls.

Lesson 3 • Communication Patterns in Distributed Systems

Compares synchronous RPC, asynchronous messaging, and event streaming for inter-service calls. Students select communication patterns based on coupling and reliability needs.

Lesson 4 • Distributed Systems Fundamentals

Covers fallacies of distributed computing, network partitions, and latency realities. Students calibrate assumptions before designing distributed solutions.

Lesson 1 • Performance Modelling and Profiling

Introduces queuing theory, Amdahl's law, and profiling techniques for identifying bottlenecks. Students build performance models before committing to architectural changes.

Lesson 2 • Load Balancing and Traffic Management

Examines load balancing algorithms, health checks, and traffic shaping for high-availability deployments. Students configure routing strategies that maximise throughput and minimise latency.

Lesson 3 • Horizontal and Vertical Scaling Strategies

Compares scaling up hardware with scaling out instances and the architectural implications of each. Students design stateless services and shared-nothing architectures for horizontal scale.

Lesson 4 • Caching Architectures

Covers in-process, distributed, and CDN caching layers and their consistency implications. Students select cache placement and invalidation strategies for specific access patterns.

Lesson 1 • Threat Modelling for Architects

Applies STRIDE and attack tree methods to identify threats during design. Students produce threat models that drive security requirements and control selection.

Lesson 2 • Secure Communication and Data Protection

Addresses encryption in transit, at rest, and key management architecture. Students select cryptographic controls appropriate to data sensitivity and compliance requirements.

Lesson 3 • Authentication and Authorisation Patterns

Covers identity federation, token-based authentication, and role-based access control at the architecture level. Students design auth flows that scale across distributed services.

Lesson 4 • Defence-in-Depth and Segmentation

Applies layered security controls and network segmentation to limit blast radius. Students design perimeter, host, and application-layer defences as a coordinated system.

Lesson 1 • Technical Debt Management

Defines technical debt types and introduces strategies for measuring and retiring debt systematically. Students build debt backlogs and negotiate remediation with product stakeholders.

Lesson 2 • Measuring Architectural Health

Introduces metrics such as coupling, cyclomatic complexity, and deployment frequency as health indicators. Students build dashboards that make architectural degradation visible.

Lesson 3 • Architecture Governance Models

Compares centralised, federated, and enabling governance models for architecture standards. Students design governance that balances consistency with team autonomy.

Lesson 4 • Architecture Review Methods

Covers ATAM, lightweight architecture evaluation, and peer review formats. Students facilitate structured reviews that surface risks before implementation.