Threads to Clusters

From Single Thread to Multi-Cloud

47 modules

193 lessons

—

Part 1

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why "Threads to Clusters"Sign in
How to Use This CourseSign in
The Incremental Ladder (Step 0 to Step 7)Sign in
The Course LensesSign in

Part 2

Mental Models: Threads, Processes, Nodes, Clusters

Mental Models: Threads, Processes, Nodes, ClustersSign in
Core DefinitionsSign in
Scaling ModelsSign in
Failure DomainsSign in

Part 3

Architectures as Layers

Architectures as LayersSign in
The Layered ViewSign in
Concern PlacementSign in
Why You Don't Skip RungsSign in

Part 4

Diagramming and Notation

Diagramming and NotationSign in
Canonical Symbols and LegendsSign in
Notation StylesSign in
Reading and Writing Architecture DiagramsSign in

Part 5

Step 0 Architecture: Single-Threaded Systems

Step 0 Architecture: Single-Threaded SystemsSign in
Classical Monolith ShapeSign in
Event Flow and Blocking I/OSign in
Packaging and Manual DeploymentSign in

Part 6

Step 0 Operations: Local Data, Logging, Configuration

Step 0 Operations: Local Data, Logging, ConfigurationSign in
Local Persistence ModelsSign in
Configuration and Secrets on One HostSign in
Debugging and Local ObservabilitySign in

Part 7

Step 1 Compute: Threads and Async

Step 1 Compute: Threads and AsyncSign in
Concurrency Primitives: Work Queues, Thread Pools, Async RuntimesSign in
Shared Memory Hazards: Locks, Deadlocks, Contention, False SharingSign in
Canonical Patterns: Producer/Consumer, Reactor/Event Loop, Futures/PromisesSign in

Part 8

Step 1 Operations: Packaging and Running Concurrent Apps

Step 1 Operations: Packaging and Running Concurrent AppsSign in
CPU-bound vs I/O-bound: Choosing Concurrency StrategiesSign in
Runtime Tuning: Thread Counts, Pools, and Saturation BehaviorSign in
Profiling and Debugging Concurrency: Practical Diagnosis and Anti-Pattern RecognitionSign in

Part 9

Step 2 Architecture: Multi-Process Systems

Step 2 Architecture: Multi-Process SystemsSign in
Process Decomposition: Web Server, Worker, Scheduler as Separate ProcessesSign in
IPC Patterns: Pipes, Unix Sockets, Shared Memory, Localhost TCPSign in
Supervision and Lifecycle: Init Systems and Supervisors (Systemd-like Patterns)Sign in

Part 10

Step 2 Operations: Distribution, Security, Observability on One Host

Step 2 Operations: Distribution, Security, Observability on One HostSign in
Packaging Process Topologies: Bundles, Installers, and Dependency AlignmentSign in
Local Perimeter Thinking: Loopback Security and Host Firewall BasicsSign in
Structured Logs and Host Metrics: Preparing for the Container LeapSign in

Part 11

Containers as the New Process

Containers as the New ProcessSign in
Isolation Mechanics: Namespaces, cgroups, Container BoundariesSign in
Designing Container Cuts: Mapping Multi-Process Apps to ContainersSign in
Sidecar vs Single-Container: Trade-offs and Operational ConsequencesSign in

Part 12

Image Build, Packaging, Distribution

Image Build, Packaging, DistributionSign in
Dockerfile/OCI Design: Layers, Base Images, Multi-Stage BuildsSign in
Registries and Tagging: Immutability, Promotion, Provenance (SBOM as Baseline)Sign in
Reproducibility: Dev-to-Prod Workflows and Artifact DisciplineSign in

Part 13

Single-Host Container Networking and Security

Single-Host Container Networking and SecuritySign in
Bridge vs Host Networking: Port Mapping and Local RoutingSign in
Local Naming/DNS: Service Naming on One HostSign in
Least Privilege Containers: Users, Filesystem Permissions, Minimal ImagesSign in

Part 14

Operating Containerized Single-Host Systems

Operating Containerized Single-Host SystemsSign in
Multi-Container Topologies: Compose-like Orchestration PatternsSign in
Health, Restarts, Failover: Liveness, Readiness, Restart PoliciesSign in
Container Observability: Logs, Metrics, Tracing Basics Inside ContainersSign in

Part 15

Cluster Primitives

Cluster PrimitivesSign in
Workload Building Blocks: Pods/Tasks, Deployments, Jobs, DaemonSetsSign in
Control Plane and Scheduling: Placement, Resourcing, Node PoolsSign in
Requests/Limits and Bin Packing: Performance, Stability, Noisy NeighborsSign in

Part 16

Cluster Networking and Service Discovery

Cluster Networking and Service DiscoverySign in
East-West Traffic: Pod Networks and Service AbstractionsSign in
Cluster DNS and Naming: Conventions and Failure BehaviorSign in
L4 vs L7 Inside the Cluster: Load Balancing and Routing DecisionsSign in

Part 17

Ingress, Edge, External Access

Ingress, Edge, External AccessSign in
Ingress Controllers and Gateways: Edge Patterns and ResponsibilitiesSign in
TLS Termination and mTLS: Secure Traffic Inside and Outside the ClusterSign in
Public vs Private Ingress: Allowlists, WAF Integration, Exposure ControlSign in

Part 18

Packaging for Clusters

Packaging for ClustersSign in
Manifests and Charts: Helm/Kustomize Mental ModelsSign in
Versioning and Release Mechanics: Promotion and Rollback StrategySign in
Config and Secrets at Scale: Operational Models and Drift ControlSign in

Part 19

Data, State, Storage in a Single Cluster

Data, State, Storage in a Single ClusterSign in
Stateful Workloads: PVCs, Storage Classes, Stateful SetsSign in
DB Inside vs Outside: Trade-offs and Operational PostureSign in
Cache Placement: Cluster-Local vs External TiersSign in

Part 20

Observability and Reliability in a Single Cluster

Observability and Reliability in a Single ClusterSign in
Central Telemetry: Logging, Metrics, Tracing Stacks and PatternsSign in
Probes and Autoscaling: Readiness/Liveness, HPA Patterns, Disruption BudgetsSign in
Incident Operations: Canary, Blue/Green, and Recovery WorkflowsSign in

Part 21

Why Multi-Cluster

Why Multi-ClusterSign in
Isolation Models: Per-Tenant, Per-Team, Per-Env MotivationsSign in
Trade-offs vs One Mega-Cluster: Complexity, Cost, Failure IsolationSign in
When Multi-Cluster Is Justified: Thresholds and TriggersSign in

Part 22

Topologies: Cell-Based and Hub-and-Spoke

Topologies: Cell-Based and Hub-and-SpokeSign in
Cells/Shards vs Shared Control: Design Choices and ConsequencesSign in
Ingress Models: Per-Cluster Ingress vs Shared Ingress LayersSign in
Regional Segmentation: Network Segmentation Patterns in One RegionSign in

Part 23

Cross-Cluster Networking and Discovery

Cross-Cluster Networking and DiscoverySign in
Private Networking: VPC/VNet Peering and Private LinksSign in
Federation and Mesh: DNS, Mesh Federation, and Discovery PatternsSign in
Routing Strategies: Failover, Shadowing, Regional Load BalancingSign in

Part 24

Data and Caching Across Clusters

Data and Caching Across ClustersSign in
Shared vs Per-Cluster Datastores: Governance and Blast RadiusSign in
Cache Tiers: Cluster-Local vs Shared Cache BackbonesSign in
Event Buses: Messaging as the Cross-Cluster Integration PlaneSign in

Part 25

CI/CD, Packaging, Governance

CI/CD, Packaging, GovernanceSign in
Artifact Promotion: Images and Configuration Across ClustersSign in
GitOps and Pipelines: Multi-Cluster Deployment MechanicsSign in
Policy as Code: Admission Control, Scanning, and ComplianceSign in

Part 26

Regions and Failure Domains

Regions and Failure DomainsSign in
Regions/AZs as Boundaries: What Can Fail TogetherSign in
Active-Active vs Active-Passive: Availability ModelsSign in
RTO/RPO: Defining Recovery Objectives and ConstraintsSign in

Part 27

Global Traffic Management and DNS

Global Traffic Management and DNSSign in
Global DNS Policies: Latency, Geo, and Failover StrategiesSign in
Anycast and CDN Edges: Routing Implications and Trade-offsSign in
Health-Based Failover: Combining DNS and L7 RoutingSign in

Part 28

Data Replication and Consistency

Data Replication and ConsistencySign in
Strong vs Eventual: What You Can Promise GloballySign in
Topologies: Leader-Follower, Multi-Leader, Conflict ResolutionSign in
Replication Failure Modes: Lag, Split-Brain, ReconciliationSign in

Part 29

Caching and Performance at Global Scale

Caching and Performance at Global ScaleSign in
Edge vs Regional Caches: Placement and CoherenceSign in
Invalidation Strategies: TTLs, Hints, Stampede MitigationSign in
Read-Mostly vs Write-Heavy: Performance Posture and ConstraintsSign in

Part 30

Security, Identity, Compliance Across Regions

Security, Identity, Compliance Across RegionsSign in
Data Residency: Region-Specific Compliance ImpactsSign in
Federated Identity: Region-Aware AuthZ and PolicySign in
Key Management: KMS/HSM Patterns and Secure DistributionSign in

Part 31

Operating Multi-Region Systems

Operating Multi-Region SystemsSign in
Failover Playbooks: Drains, Failback, CutoversSign in
Game Days and DR Rehearsals: Operational ValidationSign in
Global Observability: SLOs per Region, Aggregation, Incident CoordinationSign in

Part 32

Why Multi-Cloud

Why Multi-CloudSign in
Real Motivations vs Myths: Risk, Locality, Negotiation, Capability GapsSign in
When Multi-Region Is Enough: Avoiding Unnecessary ComplexitySign in
Anti-Goals: What Multi-Cloud Should Not Be Used to SolveSign in

Part 33

Abstraction Layers and Control Planes

Abstraction Layers and Control PlanesSign in
Cloud-Agnostic vs Cloud-Native: The Portability Trade SpaceSign in
Common Control Planes: Orchestration and Policy PatternsSign in
Contracts and APIs: Minimizing Lock-In Through Explicit InterfacesSign in

Part 34

Networking Across Clouds

Networking Across CloudsSign in
Connectivity Options: VPN, Direct Connect, OverlaysSign in
Routing and DNS: Naming and Traffic Management Across ProvidersSign in
Cost and Latency: Egress, Bottlenecks, and Optimization PostureSign in

Part 35

Identity, Access, Policy Federation

Identity, Access, Policy FederationSign in
Cross-Cloud SSO: Federated Identity FundamentalsSign in
Consistent Authorization: RBAC/ABAC Across ProvidersSign in
Policy as Code at Multi-Cloud Scope: Enforcement and AuditingSign in

Part 36

Data Portability and Gravity

Data Portability and GravitySign in
Data Gravity: why data dominates architecture decisionsSign in
Replication and DR: cross-cloud backup and recovery modelsSign in
Portability Boundaries: what must be portable vs what can be per-cloudSign in

Part 37

Packaging and Distribution for Multi-Cloud

Packaging and Distribution for Multi-CloudSign in
Portable Artifacts: images, manifests, infra-as-code disciplineSign in
Multi-Cloud Pipelines: promotion and verificationSign in
Extensions: provider-specific vs provider-neutral patternsSign in

Part 38

Compute and Concurrency Patterns

Compute and Concurrency PatternsSign in
Thread Pools, Work Queues, and Saturation BoundariesSign in
Async I/O, Event Loops, and BackpressureSign in
Actors, Green Threads, and Isolation-by-MailboxSign in
Request/Response vs Event-Driven vs Batch: Choosing the Work ModelSign in
Scaling Patterns Across the Ladder: When "More Instances" FailsSign in

Part 39

Integration, Messaging, Event-Driven Architectures

Integration, Messaging, Event-Driven ArchitecturesSign in
Integration Boundaries: App Layer vs Data Layer vs Infra LayerSign in
Queues, Topics, Streams: Semantics and Operational Trade-offsSign in
Change Data Capture and the Event BackboneSign in
The Outbox Pattern: Making Side Effects DurableSign in
Sagas and Distributed Workflows: Coordinating Without a Global TransactionSign in

Part 40

Caching and Performance Patterns

Caching and Performance PatternsSign in
Cache-Aside, Read-Through, Write-Through, Write-Behind: What You PromiseSign in
Hot Keys, Hot Partitions, and Load SkewSign in
Cache Stampede and Thundering Herd: Prevention and MitigationSign in
Local -> Cluster -> Global: How Cache Boundaries Evolve Up the LadderSign in
Consistency Hints: TTLs, Invalidation, and "Good Enough" CorrectnessSign in

Part 41

Load Balancing and Traffic Shaping Patterns

Load Balancing and Traffic Shaping PatternsSign in
L4 vs L7 Load Balancing: Connection vs Request SemanticsSign in
Blue/Green and Canary: Release Safety as a Boundary DesignSign in
Shadow Traffic and A/B Testing: Measurement Without Breaking UsersSign in
Rate Limiting and Quotas: Protecting Shared SystemsSign in
Backpressure, Circuit Breakers, and Overload ControlSign in

Part 42

Security Architecture and Zero Trust

Security Architecture and Zero TrustSign in
Authentication vs Authorization: What Each Boundary EnforcesSign in
RBAC, ABAC, and Policy Evaluation: Consistency Across StepsSign in
Perimeter to Microsegmentation: Network Segmentation PatternsSign in
Secrets Distribution and Rotation: Secure Bootstrapping Over TimeSign in
Service Mesh and Zero Trust: When It Helps, When It HurtsSign in

Part 43

Observability, SLOs, Operational Maturity

Observability, SLOs, Operational MaturitySign in
Metrics, Logs, Traces: Signals and Failure BoundariesSign in
SLIs and SLOs: Turning "Reliability" Into a ContractSign in
Error Budgets and Release Policy: Governing Change with DataSign in
Alerting and On-Call Design: Avoiding Paging as a Monitoring StrategySign in
Operational Maturity by Step: Readiness Criteria Across the LadderSign in

Part 44

Diagram Templates by Step

Diagram Templates by StepSign in
Diagram Templates by StepSign in

Part 45

Technology Mapping Guide

Technology Mapping GuideSign in
Technology Mapping GuideSign in

Part 46

Readiness Assessments: Moving from Step N to Step N+1

Readiness Assessments: Moving from Step N to Step N+1Sign in
Readiness Assessments: Moving from Step N to Step N+1Sign in

Part 47

Glossary: Canonical Definitions (and the Boundaries They Imply)

Glossary: Canonical Definitions (and the Boundaries They Imply)Sign in
Glossary: Canonical Definitions (and the Boundaries They Imply)Sign in

Course overview