A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Foundations Start here
F1. The Architect Role
Beginner · 45 min
A solutions architect sits between the business problem and the technical system, fluent in both. Learn what the role actually is — not the most senior coder, but the person who owns the shape of a solution, its trade-offs and its "why" — and the difference between a solutions, enterprise and cloud architect.
Skills: Business ↔ technical · Owning the trade-offs · Architect archetypes · Breadth over depth
Build it: A stakeholder asks for "a microservices platform." What questions do you ask before that word survives the meeting?
F2. Cloud Fundamentals
Beginner · 55 min
Modern architecture is cloud architecture. Learn the core building blocks — compute, storage, networking, identity — the managed-vs-self-hosted decision, regions and availability zones, and the shared-responsibility model, so you can compose services into a system instead of reinventing each one from raw servers.
Skills: Compute, storage, network · Managed vs self-hosted · Regions & AZs · Shared responsibility
Build it: For a new app, list which pieces you’d take as managed services and which you’d run yourself — and why.
F3. Networking & Security
Intermediate · 55 min
Every architecture is a network with a security boundary. Learn VPCs and subnets, load balancing and DNS, and the identity layer — IAM, roles, least privilege — plus where encryption in transit and at rest belongs, so the system you draw is one a security review will actually approve.
Skills: VPCs & subnets · Load balancing & DNS · IAM & least privilege · Encryption in transit/at rest
Build it: Sketch the network boundary for a public API that talks to a private database. What must never be reachable from the internet?
F4. Compute & Storage
Intermediate · 50 min
Choosing the right compute and storage shape is half of architecture. Learn the spectrum — VMs, containers, serverless — and the storage families — object, block, file — with the cost, latency and operational trade-offs of each, so "just use Lambda" or "just use S3" becomes a reasoned choice, not a reflex.
Skills: VMs, containers, serverless · Object/block/file storage · Cost & latency trade-offs · Right-sizing
Build it: A workload runs 30 seconds once an hour. Argue serverless vs a VM on cost and cold-start, and pick one.
F5. Databases & Data
Intermediate · 55 min
Data outlives every service around it, so its shape is the most consequential choice you make. Learn SQL vs NoSQL, when each fits, OLTP vs OLAP, caching, and the CAP trade-offs that decide whether your system stays consistent or available when the network splits — because you cannot have both.
Skills: SQL vs NoSQL · OLTP vs OLAP · Caching layers · CAP trade-offs
Build it: A team defaults to one database for everything. Give two workloads where that’s wrong and what you’d pick instead.
F6. Infrastructure as Code
Intermediate · 50 min
An architecture that lives only in a diagram drifts from reality within a week. Learn infrastructure as code — Terraform/OpenTofu, state, modules, plan-and-apply discipline — so the system you design is version-controlled, reviewable and reproducible, and the diagram and the running cloud stay the same thing.
Skills: Terraform / OpenTofu · State & modules · Plan/apply discipline · Reproducible infra
Build it: Someone hand-edits a resource in the console that IaC also manages. Explain the drift this causes and how the next apply behaves.
Designing Systems The craft
T1. The Well-Architected Way
Intermediate · 55 min
Cloud providers distilled decades of architecture into a small set of pillars — operational excellence, security, reliability, performance, cost, and sustainability. Learn to use them as a review lens: a structured set of hard questions you ask about any design to find the weak pillar before production does.
Skills: The pillars · Trade-offs between pillars · Architecture reviews · Finding the weak pillar
Build it: A design is fast and cheap but has one region and no backups. Which pillars does it fail, and what’s the minimum fix?
T2. Scalability & HA
Intermediate · 55 min
Design for the load you’ll have, not the load you have. Learn horizontal vs vertical scaling, statelessness, load balancing and the database as the usual bottleneck, plus high-availability patterns — redundancy, multi-AZ, no single point of failure — so growth is a config change, not a rewrite.
Skills: Horizontal vs vertical · Statelessness · Removing SPOFs · Multi-AZ HA
Build it: A design puts session state in the app server’s memory. Explain why that blocks horizontal scaling and how you’d fix it.
T3. Resilience & DR
Advanced · 50 min
Everything fails eventually; resilient systems degrade instead of collapsing. Learn timeouts, retries and circuit breakers, graceful degradation, and disaster recovery defined by two numbers — RTO and RPO — plus the backup, replication and failover strategy that actually meets them when a whole region goes dark.
Skills: Graceful degradation · Retries & circuit breakers · RTO & RPO · Backup & failover
Build it: The business says "zero downtime, zero data loss." Explain the cost reality behind RTO=0 and RPO=0 and how you’d negotiate it.
T4. Cost Optimization
Advanced · 50 min
In the cloud, architecture is a monthly bill, and the architect owns it. Learn the FinOps mindset — right-sizing, reserved vs spot capacity, storage tiering, and killing idle waste — plus how to make cost a first-class design constraint so the elegant system you drew doesn’t quietly become the one finance asks you to defend.
Skills: FinOps mindset · Right-sizing · Reserved vs spot · Cost as a design input
Build it: A dev/test environment runs 24/7 but is used 40 hours a week. Estimate the waste and the simplest fix.
T5. Integration Patterns
Advanced · 55 min
Real systems are made of parts that must talk. Learn the integration toolkit — synchronous APIs and gateways, asynchronous queues and events, webhooks, and the event-driven patterns that decouple producers from consumers — and when each is right, so services stay independent instead of collapsing into a distributed monolith.
Skills: Sync APIs & gateways · Async queues & events · Webhooks · Event-driven decoupling
Build it: Two services are tightly coupled through synchronous calls and fail together. Redesign the seam so one can be down without the other.
T6. Migration Strategies
Advanced · 50 min
Most architecture work is changing a system that already exists and can’t stop. Learn the migration playbook — the 6 Rs (rehost, replatform, refactor…), the strangler-fig pattern for retiring a monolith incrementally, and how to move data and cut over without the big-bang rewrite that so reliably ends in disaster.
Skills: The 6 Rs · Strangler-fig pattern · Data migration & cutover · Avoiding big-bang rewrites
Build it: A 10-year-old monolith must move to the cloud with no downtime. Sketch a strangler-fig plan for the first slice.
The Craft The human system
P1. Requirements & Discovery
Advanced · 50 min
The most expensive architecture mistakes are made before any diagram exists. Learn to run discovery — separate functional from non-functional requirements, pin down the real numbers behind "fast" and "scalable," surface constraints and hidden assumptions — so you design for the actual problem, not the one that was easiest to state.
Skills: Functional vs non-functional · Quantifying "fast" · Surfacing constraints · Finding the real problem
Build it: A client says "it must be scalable." Write the three questions that turn that word into a number you can design against.
P2. Architecture Decisions
Advanced · 45 min
An architecture is a stack of decisions, and the reasoning behind them is worth more than the diagram. Learn to write Architecture Decision Records — the choice, the alternatives, the trade-offs, the context — so future teams (and future you) know why the system is the way it is, and can revisit a decision instead of cargo-culting it.
Skills: Writing ADRs · Capturing alternatives · Recording trade-offs · Decisions over diagrams
Build it: Write a one-paragraph ADR for choosing PostgreSQL over a document store — including the trade-off you knowingly accepted.
P3. Security & Compliance
Advanced · 50 min
At the architecture level, security and compliance are design constraints, not a final gate. Learn threat modeling, data residency and privacy regimes (GDPR, SOC 2, HIPAA), and how to design defense in depth and auditability in from the start — because retrofitting compliance onto a finished system is the expensive way to learn this lesson.
Skills: Threat modeling · Data residency & privacy · Compliance regimes · Defense in depth
Build it: A system stores EU user data on US servers. Name the compliance problem and the architectural change that resolves it.
P4. Stakeholder Communication
Advanced · 50 min
An architecture no one buys into never gets built. Learn to communicate a design to every audience — a napkin sketch for an exec, a sequence diagram for engineers, a cost model for finance — to run a design review that surfaces objections early, and to sell the trade-offs so the room owns the decision with you.
Skills: Diagrams for the audience · Design reviews · Selling trade-offs · Building buy-in
Build it: You must explain the same system to a CFO and a senior engineer. Describe how the two explanations differ — and what stays the same.
P5. Multi-Cloud & Hybrid
Advanced · 45 min
Sometimes one cloud isn’t the answer — or isn’t allowed. Learn the real reasons for multi-cloud and hybrid (regulation, acquisitions, avoiding lock-in, on-prem legacy), the heavy cost in complexity they carry, and how to weigh portability against depth so "multi-cloud" is a deliberate strategy, not resume-driven architecture.
Skills: Reasons for multi-cloud · Hybrid & on-prem · Lock-in vs depth · The complexity cost
Build it: A team wants multi-cloud "to avoid lock-in." Argue the honest cost of that choice and when it’s actually worth paying.
P6. The Architect Career
Advanced · 45 min
The architect’s influence comes from trust, not authority. Learn how the role grows — staying technical enough to be credible while zooming out to systems and orgs, choosing between the solutions, enterprise and cloud-architect paths, and the discipline of leaving room for the teams who build it to make real decisions of their own.
Skills: Influence over authority · Staying technical · Architect career paths · Empowering builders
Build it: You could specify every detail or leave room for the team. Explain the trade-off and where you’d draw the line.