Distributed Systems and Cloud-Native Architecture

About this course

How large systems behave when the network, the clock and the hardware all misbehave, and how to architect for it. Learners work from the fundamental limits (partial failure, CAP and PACELC, consistency models, clocks and consensus) to the patterns and platforms that tame them: resilience patterns, Kubernetes and serverless runtimes, multi-zone and multi-region designs, cell-based architecture, capacity planning, observability and SLOs, incident learning and platform engineering. Real outages are dissected throughout.

For: software engineer, architect, tech leader.

Learning outcomes

On successful completion you will be able to:

1. 1Explain critically the fundamental limits of distributed systems (partial failure, CAP and PACELC, consistency models, clocks and consensus) and their consequences for system design.
2. 2Apply resilience patterns (deadlines, retries with backoff and jitter, idempotency, circuit breakers, bulkheads, backpressure and load shedding) so that a service tolerates partial failure.
3. 3Evaluate runtime platforms (containers and Kubernetes, serverless, managed services) and decomposition options against workload, team and cost criteria.
4. 4Design multi-zone and multi-region architectures with explicit RTO and RPO, failover strategies and blast-radius containment such as cells and shuffle sharding.
5. 5Design an observability and capacity strategy for a cloud-native system, including SLIs, SLOs, error budgets, load models and performance tests.
6. 6Take responsibility for a system's reliability posture - lead incident analysis, judge acceptable risk against cost, and justify the resulting decisions to stakeholders.
7. 7Shape a platform-engineering approach (paved roads, golden paths, self-service guardrails) that lets autonomous teams adopt sound runtime practices.

Modules and lessons

1. Week 1Fundamentals of distribution⌄

   • Partial failure: why distributed systems are hard
   • Consistency models, CAP and PACELC
2. Week 2Time, ordering and consensus⌄

   • Time, clocks and ordering
   • Consensus, replication and leader electioncase study
3. Week 3Resilience patterns⌄

   • Timeouts, retries and idempotencylab
   • Circuit breakers, bulkheads and overload protection
4. Week 4Cloud-native runtimes⌄

   • Containers and Kubernetes as an architectural platform
   • Serverless, managed services and choosing a runtime
5. Week 5Regions, recovery and blast radius⌄

   • Availability zones, regions and disaster recoverycase study
   • Cell-based architecture and blast-radius reductioncase study
6. Week 6Performance and capacity⌄

   • Performance, queueing and tail latency
   • Capacity planning and load testinglab
7. Week 7Observability and reliability practice⌄

   • Observability, SLIs and SLOs
   • Incidents, postmortems and chaos engineeringcase study
8. Week 8Platforms and runtime concerns⌄

   • Platform engineering and paved roads
   • Service mesh, gateways and cross-cutting runtime concerns

Assessment

• Quiz (10%)

  Eight weekly quizzes drawn from the lesson quiz banks; best seven count.

• Lab (20%)

  Resilience and load-testing lab - inject faults into a service chain, add resilience patterns and show tail latency held within an agreed SLO.

• Design review (35%)

  Multi-region architecture for a provided case with RTO and RPO targets, a cell design, a runtime-platform choice and supporting ADRs.

• Case analysis (15%)

  Written post-incident analysis of a published outage, tracing root causes to distributed-systems principles and proposing architectural remedies.

• Viva (20%)

  Thirty-minute review-board defence of the multi-region design, including a live failure scenario posed by the panel.

Pass mark 60%. Grades: Distinction, Merit, Pass.