Be Wise Apps
Leer en español · Lire en français · Auf Deutsch lesen
New to software? Start here
A path for beginners
This path takes you through the chapters in order, from Chapter 0 to Chapter 12, because each chapter builds on the one before. It takes you from no technical background to the design of AI-enabled systems in six stages, with a method for getting through the harder sections without getting stuck.
The path at a glance
- Order
- The chapters in their natural order, 0 to 12, grouped into six stages
- Time
- About 40 hours of reading and 10 hours of video. At four hours a week, that is roughly three months
- Harder sections
- 32 sections are marked Advanced. On your first pass, give them a lighter read and come back later
- Tests
- Optional. Take each chapter test when you finish the chapter if you want the certificate
How to study each section
- Watch the video lessonEvery section opens with a narrated video of about four to six minutes. It gives you the shape of the idea before you read about it.
- Read “The idea in brief” and “What you need to know”The everyday explanation and the key points. If you take nothing else from a section, take these.
- Check “Before you read this”Harder sections open with a box listing the earlier sections and terms they rely on. If any of them is new to you, go back to it first, or tap a term for a short definition.
- Read the full treatmentOn a first read, it is fine to skim detailed tables, formulas and code examples. Aim to follow the argument; the detail will make more sense on a second pass.
- Try “Check your understanding”Answer each question in your head before you look. If several answers surprise you, re-read the section’s key points before moving on.
Sections marked Advanced
Each section shows its level. When you reach one marked Advanced for the first time, watch the video and read the idea in brief and the key points, then carry on. Later sections may refer back to it, so do not skip it entirely, but you do not need to master the full detail on your first time through. Come back to it once you have finished the stage.
Beginner mode and the readiness questions
Every section page has a Beginner mode switch at the top. When it is on, the most technical tables, code and “Going deeper” boxes are folded away until you tap Show, and every term you can tap for a definition is marked with a small ?. Nothing is removed, and the chapter tests cover the folded parts too. Choosing the path for beginners on the home page switches it on; you can turn it off on any section page.
From Chapter 1 onwards, each chapter page also opens with five quick questions, “Am I ready for this chapter?”, on the earlier ideas the chapter relies on. They are not marked or saved: a wrong answer simply tells you which earlier section to look at again.
When something does not make sense
- Look at the “Before you read this” box at the top of the section: the gap is often an earlier idea.
- Tap any underlined term for a short definition, or look it up in the glossary.
- Re-watch the video lesson, or use its transcript to read it at your own pace.
- Ask ArchitectBot, the course’s study assistant, to explain the idea in simpler terms.
- If you are still stuck, move on and come back: many ideas become clearer once you have seen them used in later sections.
A useful companion. The course Glossary gives short, plain definitions of more than 900 terms used in the chapters, each linked to the chapter that explains it. Keep it open in another tab while you study and look up any word that is new to you.
Stage 1 · Chapter 0
Start from nothing
Chapter 0 assumes no technical background. It explains programs, data, networks, storage, APIs and the cloud: the building blocks every later chapter takes for granted. Do not skip it, even if parts feel familiar.
Chapter 0: Start Here: How Software Works
You will learn to:
- Explain what happens, step by step, when a program runs, from source code through the operating system to the processor.
- Distinguish the common data structures and use Big-O notation to predict how an operation slows down as data grows.
The 8 sections
- 0.1 Programs, code and how a computer runs them
- 0.2 Data, data structures and algorithms, and why speed depends on them
- 0.3 Functions, modules, objects, interfaces, libraries and frameworks
- 0.4 Networks, the internet and the web: IP, DNS, HTTP and the client-server model
- 0.5 Files and databases: relational and non-relational storage, queries and transactions
- 0.6 APIs, JSON and how separate systems work together
- 0.7 Servers, operating systems, virtual machines, containers and cloud services
- 0.8 Requirements, version control, testing, delivery and the journey of one request
Stage 2 · Chapters 1 to 2
What architecture is for
Chapter 1 explains what software architecture is and why its decisions matter. Chapter 2 turns vague goals such as “fast” and “secure” into precise requirements. Together they give you the vocabulary for everything that follows.
Chapter 1: What Software Architecture Is
You will learn to:
- Explain the ISO/IEC/IEEE 42010:2022 and SEI definitions of software architecture and the ideas they share.
- Distinguish module, component-and-connector and allocation structures, and an architecture from its description.
The 8 sections
- 1.1 What software architecture is: the standard definitions and what they share
- 1.2 Architecture, design and code: significance, scope and levels
- 1.3 Why architecture matters: cost of change, quality, risk and real failures
- 1.4 What an architect does: responsibilities, skills and kinds of architect
- 1.5 Stakeholders, their concerns and how architecture serves them
- 1.6 Architectural decisions and trade-offs: reversibility and timing
- 1.7 Technical debt, architecture erosion and drift
- 1.8 Architecture across the lifecycle: up-front, emergent and continuous architecture
Chapter 2: Quality Attributes and Architecturally Significant Requirements
You will learn to:
- Distinguish functional requirements, quality attributes and constraints, and recognise an architecturally significant requirement.
- Use the ISO/IEC 25010:2023 product quality model as a checklist without letting it turn into paperwork.
The 8 sections
- 2.1 Functional requirements, quality attributes and constraints
- 2.2 The quality models: ISO/IEC 25010 and how to use it
- 2.3 Writing quality attribute scenarios that can be tested
- 2.4 Performance and scalability: latency, throughput, percentiles and load
- 2.5 Availability and reliability: nines, MTBF, MTTR and fault tolerance
- 2.6 Modifiability, testability and deployability: designing for change
- 2.7 Security, usability, interoperability, cost and sustainability as qualities
- 2.8 Eliciting, prioritising and trading off quality attributes
Stage 3 · Chapters 3 to 4
Good structure, and how to describe it
Chapter 3 introduces the principles behind a good structure, such as modularity and coupling. Being able to read a little code helps here but is not essential. Chapter 4 shows how architects draw and record their designs; its diagrams and decision records appear throughout the rest of the course.
Chapter 3: Design Principles and Fundamentals
You will learn to:
- Explain Parnas's criterion for decomposing a system into modules and apply it to compare two candidate decompositions.
- Classify dependencies using the classic levels of coupling and cohesion, and identify temporal, deployment and semantic coupling between services.
The 8 sections
- 3.1 Modularity: dividing a system into parts
- 3.2 Coupling and cohesion
- 3.3 Information hiding, abstraction and interfaces
- 3.4 Managing dependencies: direction, cycles and stability
- 3.5 The SOLID principles applied to components
- 3.6 Connascence: a finer measure of coupling
- 3.7 Conway's law and the shape of organisations
- 3.8 Simplicity, reversibility and measuring structure
Chapter 4: Documenting and Communicating Architecture
You will learn to:
- Explain who reads architecture documentation, what each reader needs and how to decide what is worth writing down.
- Distinguish stakeholders, concerns, viewpoints, views and model kinds as defined by ISO/IEC/IEEE 42010:2022.
The 8 sections
- 4.1 Why and how much to document
- 4.2 Views and viewpoints: ISO/IEC/IEEE 42010, 4+1 and Rozanski and Woods
- 4.3 The C4 model: context, containers, components and code
- 4.4 The UML diagrams architects still use
- 4.5 Architecture Decision Records
- 4.6 arc42 and other documentation templates
- 4.7 Diagrams as code and keeping documentation current
- 4.8 Communicating architecture to different audiences
Stage 4 · Chapters 5 to 6
Architectural styles
Chapter 5 covers systems built and deployed as one unit. Chapter 6 takes the same questions across a network, where things get harder; this is the first chapter most beginners find demanding, so take it slowly.
Chapter 5: Architectural Styles I: Monoliths and Modular Designs
You will learn to:
- Distinguish architectural styles, patterns, tactics and reference architectures, and explain why a style's constraints produce its qualities.
- Compare technical and domain partitioning and predict how each affects the cost of a typical change and the organisation of teams.
The 8 sections
- 5.1 Architectural styles, patterns and tactics
- 5.2 Layered architecture
- 5.3 The modular monolith
- 5.4 Pipes and filters and pipeline architectures
- 5.5 Microkernel and plug-in architectures
- 5.6 Hexagonal, onion and clean architecture
- 5.7 Strategic domain-driven design: bounded contexts and context maps
- 5.8 When a monolith is the right answer
Chapter 6: Architectural Styles II: Distributed Systems
You will learn to:
- Explain the legitimate reasons to distribute a system and the costs each reason brings.
- Describe the eight fallacies of distributed computing and partial failure, and design responses to them.
The 8 sections
- 6.1 Why distribute, and the fallacies of distributed computing
- 6.2 Service-based architecture and service-oriented architecture
- 6.3 Microservices: principles, benefits and costsAdvanced: lighter first read
- 6.4 Event-driven architecture: brokers, mediators and event streamsAdvanced: lighter first read
- 6.5 Synchronous and asynchronous communication: REST, gRPC, GraphQL and messaging
- 6.6 Consistency models, CAP and PACELCAdvanced: lighter first read
- 6.7 Distributed transactions, sagas and the outbox patternAdvanced: lighter first read
- 6.8 Serverless and space-based architectures
Stage 5 · Chapters 7 to 9
Data, security and keeping systems running
These three chapters deal with what makes real systems hard: who owns the data and how it stays correct, how the system is protected, and how it stays fast and available under stress. Each builds on Chapter 6.
Chapter 7: Data Architecture
You will learn to:
- Explain why a shared database couples services, and assign ownership of data, including cases where several services write the same data.
- Choose a database for each data set by data shape, access patterns, consistency needs, scale, operations and team skills, and justify the cost of each additional store.
The 8 sections
- 7.1 Data ownership and database per service
- 7.2 Choosing a database: relational, document, key-value, column, graph and time-series
- 7.3 Transactions, ACID and isolation levelsAdvanced: lighter first read
- 7.4 Replication, partitioning and shardingAdvanced: lighter first read
- 7.5 CQRS and event sourcingAdvanced: lighter first read
- 7.6 Caching strategies and their pitfalls
- 7.7 Schema evolution, migrations and compatibility
- 7.8 Analytics, streaming, warehouses, lakes and data meshAdvanced: lighter first read
Chapter 8: Security, Privacy and Compliance by Design
You will learn to:
- Apply the CIA triad, Saltzer and Schroeder's design principles, defence in depth and secure defaults to architectural decisions, and explain what architects own in a secure development lifecycle.
- Threat-model a design using a data-flow diagram with trust boundaries, STRIDE and attack trees, and rate and record the resulting risks and mitigations.
The 8 sections
- 8.1 Security principles for architects
- 8.2 Threat modelling: STRIDE, attack trees and data-flow diagrams
- 8.3 Identity and access: authentication, authorisation, OAuth 2.0 and OpenID ConnectAdvanced: lighter first read
- 8.4 Encryption, key management and secretsAdvanced: lighter first read
- 8.5 Secure communication and zero trustAdvanced: lighter first read
- 8.6 Software supply-chain security
- 8.7 Privacy by design and the GDPR
- 8.8 Security in operation: logging, detection and response
Chapter 9: Performance, Scalability, Resilience and Operability
You will learn to:
- Choose between vertical and horizontal scaling and among the X, Y and Z axes of the scale cube, and size a fleet for a known peak with Little's law and headroom.
- Select autoscaling signals and settings that avoid lag and flapping, and explain why CPU is often the wrong metric.
The 8 sections
- 9.1 Scaling strategies: vertical, horizontal and the scale cube
- 9.2 Load balancing, statelessness and sessions
- 9.3 Asynchrony, queues and back pressure
- 9.4 Timeouts, retries, circuit breakers, bulkheads and graceful degradationAdvanced: lighter first read
- 9.5 SLIs, SLOs, SLAs and error budgets
- 9.6 Observability: logs, metrics and traces
- 9.7 Capacity planning and performance testingAdvanced: lighter first read
- 9.8 Chaos engineering, incidents and blameless learning
Stage 6 · Chapters 10 to 12
Cloud, governance and AI
The final stage covers the cloud platforms systems run on, how architectures are judged and governed over time, and how all of it applies to systems built around AI models. Chapters 11 and 12 draw on the whole course, so leave them until last.
Chapter 10: Cloud-Native and Infrastructure Architecture
You will learn to:
- Compare IaaS, CaaS, PaaS, FaaS and SaaS and the deployment models, and assign duties for a workload under the shared responsibility model.
- Explain how Kubernetes maintains a declared desired state through its control plane, nodes and reconciliation loops, configure requests, limits and probes, and judge when Kubernetes is overkill.
The 8 sections
- 10.1 Cloud service and deployment models
- 10.2 Containers and orchestration with KubernetesAdvanced: lighter first read
- 10.3 The twelve-factor app and cloud-native principles
- 10.4 Infrastructure as code and immutable infrastructureAdvanced: lighter first read
- 10.5 CI/CD pipelines and deployment strategies
- 10.6 Multi-region, disaster recovery and edge computingAdvanced: lighter first read
- 10.7 Platform engineering and internal developer platforms
- 10.8 FinOps, cost architecture and vendor lock-in
Chapter 11: Evaluation, Decision-Making and Governance
You will learn to:
- Explain when and why to evaluate an architecture, and run the nine steps of the ATAM to produce risks, non-risks, sensitivity points, trade-off points and risk themes.
- Facilitate lightweight reviews such as risk-storming and pre-mortems, and turn their results into a risk register with owners.
The 8 sections
- 11.1 Architecture evaluation and the ATAMAdvanced: lighter first read
- 11.2 Lightweight reviews and risk-stormingAdvanced: lighter first read
- 11.3 Fitness functions and evolutionary architectureAdvanced: lighter first read
- 11.4 Architecture governance in agile organisationsAdvanced: lighter first read
- 11.5 Team Topologies and socio-technical designAdvanced: lighter first read
- 11.6 Modernising legacy systems: strangler fig and incremental migrationAdvanced: lighter first read
- 11.7 Leadership, influence and decision-makingAdvanced: lighter first read
- 11.8 Ethics, sustainability and the business caseAdvanced: lighter first read
Chapter 12: Architecting AI-Enabled Systems
You will learn to:
- Explain how machine-learning models and large language models are trained and served, and what tokens, context windows, sampling, embeddings and hallucination mean for a system's design.
- Choose where a model should run and how it is called, and design an AI gateway, model routing, cascades, fallback ladders and human review for a given set of requirements.
The 8 sections
- 12.1 Machine learning and large language models for architectsAdvanced: lighter first read
- 12.2 Where models fit in an architectureAdvanced: lighter first read
- 12.3 Retrieval-augmented generation and vector searchAdvanced: lighter first read
- 12.4 Agents, tool use and orchestrationAdvanced: lighter first read
- 12.5 Evaluating and testing AI-enabled systemsAdvanced: lighter first read
- 12.6 Guardrails, safety and prompt injectionAdvanced: lighter first read
- 12.7 Cost, latency and LLMOpsAdvanced: lighter first read
- 12.8 Data governance, responsible AI and the EU AI ActAdvanced: lighter first read
After Chapter 12
If you have taken the chapter tests along the way, the final examination and the architecture case study open once all thirteen are passed. About the course explains how they work. If you already work with software, the route for experienced learners follows the same chapters at a faster pace.