Free course · 13 chapters · 117 video lessons · certificate

Learn software architecture, from first principles to AI-enabled systems

A complete course for beginners and working engineers: how software works, quality attributes, design principles, documentation, monoliths and microservices, data, security, resilience, cloud-native systems, governance and AI. Every chapter and every section comes with its own narrated video lesson, so you can watch, listen or read. Start any chapter whenever you like; take the tests when you are ready.

13chapters, from first principles to AI-enabled systems

104sections, each with a simple explanation, diagrams and worked examples

117narrated video lessons, about 10 hours, with captions and transcripts

936test questions, so every attempt is different

Freeno account, no email, with a verifiable certificate

Before you begin: read what the course covers, who it is for, how long it takes, how the tests are marked and what the certificate shows.

About the course

How it works

Watch or read anything, any time

Every chapter and section is open. Start at the beginning, or go straight to the topic you need. Each section opens with a short narrated video lesson and a simple explanation before it goes deep.

Take the chapter tests

Each chapter ends with an optional test: 20 multiple-choice questions and 2 short written answers, drawn afresh each time. Pass mark 80%.

Earn the certificate

Pass every chapter test, then the final assessment and a case study, to receive a Be Wise Certificate of Completion that anyone can verify online.

The course

Thirteen chapters, in a natural order

Each chapter builds on the one before. Chapter 0 assumes no technical background at all; by Chapter 12 you are designing systems built around AI models.

Start Here: How Software Works

The groundwork for everything that follows: what a program is, how data and code are organised, how computers talk over networks, where data is stored, what APIs, servers and the cloud are, and how teams build software. No prior knowledge assumed.

Beginner

What Software Architecture Is

The definitions that matter (ISO/IEC/IEEE 42010 and the SEI), how architecture differs from design, why it decides cost and risk, what architects actually do, stakeholders, trade-offs, technical debt and where architecture sits in modern delivery.

Beginner to intermediate

Quality Attributes and Architecturally Significant Requirements

How to turn vague wishes like 'fast' and 'secure' into precise, testable requirements: ISO/IEC 25010, quality attribute scenarios, performance, availability, modifiability, security and usability, and how to elicit, prioritise and trade them off.

Intermediate

Design Principles and Fundamentals

The principles behind every good structure: modularity, coupling and cohesion, information hiding, dependency rules, SOLID at component scale, connascence, Conway's law, simplicity and how to measure structure.

Intermediate

Documenting and Communicating Architecture

Views and viewpoints, the C4 model, the UML that still matters, Architecture Decision Records, arc42, diagrams as code and how to present architecture to technical and non-technical audiences.

Intermediate

Architectural Styles I: Monoliths and Modular Designs

Styles for systems deployed as one unit: layered, modular monolith, pipes and filters, microkernel, hexagonal and clean architecture, domain-driven design, and when a monolith is the right answer.

Intermediate

Architectural Styles II: Distributed Systems

Why and when to distribute, the fallacies of distributed computing, service-based and microservice architectures, event-driven systems, synchronous and asynchronous communication, CAP and PACELC, sagas, serverless and space-based designs.

Intermediate to advanced

Data Architecture

Data ownership, choosing a database, transactions and isolation, replication and partitioning, CQRS and event sourcing, caching, schema evolution, and analytics, streaming and data mesh.

Intermediate to advanced

Security, Privacy and Compliance by Design

Security principles, threat modelling with STRIDE, identity and access (OAuth 2.0 and OpenID Connect), encryption and secrets, zero trust, software supply-chain security, privacy by design under the GDPR, and security in operation.

Intermediate to advanced

Performance, Scalability, Resilience and Operability

Scaling strategies, load balancing and statelessness, queues and back pressure, timeouts, retries, circuit breakers and bulkheads, SLIs, SLOs and error budgets, observability, capacity planning and chaos engineering.

Intermediate to advanced

Cloud-Native and Infrastructure Architecture

Cloud service models, containers and Kubernetes, the twelve-factor app, infrastructure as code, CI/CD and deployment strategies, multi-region and edge, platform engineering, FinOps and lock-in as a trade-off.

Intermediate to advanced

Evaluation, Decision-Making and Governance

How architectures are judged and governed: ATAM and lightweight reviews, fitness functions and evolutionary architecture, governance in agile organisations, Team Topologies, legacy modernisation, leadership, ethics and the business case.

Advanced

Architecting AI-Enabled Systems

Machine learning and large language models from an architect's point of view: where models fit, retrieval-augmented generation, agents and tool use, evaluation, guardrails, cost and latency, LLMOps and responsible AI under the EU AI Act.

Advanced

Browse in detail the chapters

Two ways to use it

As a reference

Look up any topic: quality attribute scenarios, the C4 model, CAP and PACELC, sagas, OAuth, SLOs, retrieval-augmented generation. Use the course contents, the search and the glossary.

As a course

Work through the chapters in order with the video lessons, check yourself with the questions at the end of each section, take the chapter tests and earn the certificate. Decide your level below and start.

Where would you like to start?

Everyone takes the same chapters in the same order, from Chapter 0 to Chapter 12. Choose the guide that fits you.

Beginners

New to software? Start here

If you have no technical background, click here. The path for beginners takes you through the course in six stages, starting at Chapter 0. It shows you how to use the video lessons, the simple explanations, the “Before you read this” boxes, the glossary and ArchitectBot so that each step makes sense before you move on. Clicking here also switches on Beginner mode, a gentler view of each section that you can turn off at any time.

Follow the path for beginners → Intermediate and advanced

Already work with software? Start here

If you already build, test or manage software, click here. The route for experienced learners takes you through the same chapters in order and shows where you may prefer to skim what you already know. To obtain the certificate, you still need to pass the test at the end of every chapter.

Follow the route for experienced learners →

Questions

About the course

Is the course free?

At present the whole course is free: every chapter, the chapter tests, ArchitectBot, the final assessment and the certificate. If that changes, the price and exactly what it includes will be shown on the About the course page before you start anything that is charged for. The course is supported by clearly labelled advertising, which never affects the content, the questions or the marking.

Are there video lessons?

Yes. Every chapter opens with a narrated video introduction of about 6 to 8 minutes, and each of the 104 sections has its own narrated video lesson of about 4 to 6 minutes: 117 videos, about 10 hours in all. Each video has English captions, a “Listen only (audio)” option and the full transcript, so you can watch, listen or read, whichever suits you. The videos sit at the top of every chapter and section, in the app and on the course web pages.

Do I need to know how to program?

No. Chapter 0 assumes no technical background: it explains what programs, data, networks, databases, APIs, servers and the cloud are before the course turns to architecture. Every later section also opens with a short, simple explanation before it goes into detail. Being able to read a little code helps but is not required.

Who is the course for?

Beginners who want to understand how software systems are designed; developers moving towards senior, lead or architect roles; engineering managers and product people who work with architects; students; and AI engineers who need to place models inside reliable systems.

How long does it take?

About 40 hours of reading, at your own pace: each chapter takes roughly two to four hours to read. With the chapter tests (about 45 minutes each), the final examination and the case study, the whole course is about 60 hours of study.

Do I have to take the tests?

No. Every chapter is open to read whenever you like, in any order, so the course works as a reference as well as a course. The tests are there for anyone who wants to check their understanding or earn the certificate.

How are the tests marked?

Each chapter test has 20 multiple-choice questions, drawn afresh each time from a bank of more than 60, and 2 short written answers. Multiple choice is marked automatically. Written answers are marked by AI against criteria shown with each question, and you can ask for a second marking. To pass you need 80% overall and at least 2 out of 5 on each written answer.

What is the certificate, and is it accredited?

When you have passed every chapter test, the final assessment and a case study, you receive a Be Wise Certificate of Completion with your name, the date, your grade (Pass, Merit or Distinction) and a unique number that anyone can check on bewiseapps.com. It records that you passed this course's tests. It is not an accredited qualification and is not issued by a university or professional body.

Do I need an account?

No. No account, password or email address is needed. Your reading progress stays in your browser. When you take a test you receive a random resume code; your scores are kept against that code so you can continue on another device. Your name is stored only if you ask for a certificate, so that it can be verified.

What does the course cover?

The topics found in professional software architecture syllabuses, such as the iSAQB Foundation Level: requirements and quality attributes, design principles, architectural styles and patterns, documentation and communication, and evaluation. It then goes further into distributed systems, data architecture, security, resilience and observability, cloud-native systems, governance and AI-enabled systems. It does not prepare you for, or replace, any external examination.

What is the final assessment?

When you have passed all 13 chapter tests (the pass mark for each is 80%), the final assessment opens. It has two parts, which you can take in either order:

The final examination: 60 multiple-choice questions drawn from the whole course, to be submitted within 3 hours of starting. The pass mark is 70%. If you do not pass, you can try again with different questions after 24 hours.
The architecture case study: 1,500 to 4,000 words setting out the architecture you would propose for one of several realistic briefs. It is marked out of 50 against a published rubric of five criteria worth 10 marks each. The pass mark is 25 out of 50, with at least 4 marks on every criterion. If you do not pass, you can submit again after 24 hours.

How your grade is worked out. You receive a certificate only when you have passed every chapter test, the examination and the case study. Your overall score, out of 100, is then made up of three parts:

40% from your chapter tests: the average of your best score in each of the 13 tests;
30% from your final examination score;
30% from your case study mark, turned into a percentage (for example, 35 out of 50 is 70%).

Your grade depends on that overall score:

Distinction: an overall score of 90 or more, and at least 80% (40 out of 50) on the case study;
Merit: an overall score of 80 or more (including 90 or more without 80% on the case study);
Pass: everything passed, with an overall score below 80.

Worked example. If your best chapter test scores average 88%, you score 80% in the examination and 35 out of 50 (70%) on the case study, your overall score is (88 × 0.40) + (80 × 0.30) + (70 × 0.30) = 35.2 + 24 + 21 = 80.2, which is a Merit.

The full case study rubric is on the About the course page.

Is the course linked to a university or certification body?

No. Be Software Architecture Wise is an independent course from Be Wise. It is not affiliated with or endorsed by any university, professional body, certification scheme, technology company or author whose work it cites.

Read this before you start

About the course: what it is, who it is for and how it works

This page sets out what Be Software Architecture Wise teaches, who it suits, what you need, how long it takes, how the tests, the final assessment and the certificate work, what happens to your data, and what the course does not do.

The course at a glance

What it is: A complete online course in software architecture: 13 chapters, 104 sections and 117 narrated video lessons
Level: From no technical background (Chapter 0) to the level expected of a practising software architect
Prerequisites: None. Reading a little code helps from Chapter 3, but is not required
Time: About 40 hours of reading, about 60 with the tests and case study; self-paced, no deadlines
Format: Narrated video lessons and written chapters with diagrams, worked examples and checklists; in the app, as web pages and as PDFs
Video lessons: 117 narrated lessons: an introduction of about 6 to 8 minutes for each chapter and a lesson of about 4 to 6 minutes for each section, about 10 hours in all, each with English captions, an audio-only option and the full transcript
Assessment: Optional chapter tests (pass mark 80%), then a final examination and a written case study
Certificate: Be Wise Certificate of Completion, graded Pass, Merit or Distinction, checkable online; not accredited
Account: None needed: a random resume code keeps your scores
Price: At present the whole course is free: every chapter, the chapter tests, ArchitectBot, the final assessment and the certificate. If that changes, the price and exactly what it includes will be shown on this page before you start anything that is charged for.
Language: British English

What is Be Software Architecture Wise?

Be Software Architecture Wise is a complete online course in software architecture: the discipline of deciding how a software system is divided into parts, how those parts work together, and which trade-offs the system makes between qualities such as speed, cost, security and ease of change. It has 13 chapters and 104 sections and runs from how software works, for people with no technical background, to the design of systems built around AI models. Every chapter opens with a narrated video introduction and every section has its own short video lesson, so you can watch, listen or read.

It covers the topics found in professional software architecture syllabuses, such as the iSAQB Foundation Level, and in university software architecture modules: requirements and quality attributes, design principles, architectural styles and patterns, documentation, and evaluation. It then goes further, into distributed systems, data architecture, security and privacy by design, resilience and observability, cloud-native infrastructure, governance and leadership, and AI-enabled systems.

You can use it in two ways. As a course, you work through the chapters, take the optional test at the end of each, then sit a final assessment and an architecture case study to earn a Be Wise Certificate of Completion. As a reference, you open any chapter or section whenever you need it, in any order, without taking any test.

Who is the course for?

The course is written for a wide range of readers. Every section opens with a short, simple explanation before it goes into professional depth, so beginners and experienced engineers can use the same pages.

If you are	How the course helps
Complete beginners	Start at Chapter 0, which assumes no technical background, and follow the path for beginners. Watch the short video lesson and read the simple explanation that open every section first, check the “Before you read this” box on harder sections, tap underlined terms for definitions, and ask ArchitectBot when something is unclear.
Developers moving towards senior, lead or architect roles	Follow the route for experienced learners: take the chapters in order, skimming Chapter 0 and anything else you already know. Chapters 1 to 7 cover the core of the discipline and Chapters 8 to 11 what senior roles are expected to know.
Experienced architects and senior engineers	Follow the route for experienced learners as a structured refresher and a reference: take the chapters in order, skim what you know and use the chapter tests to check for gaps. The chapters on evaluation, governance and AI-enabled systems (11 and 12) come last and repay the closest reading.
Engineering managers, product managers and founders	Take the chapters in order, skimming the more technical detail if you wish. Chapters 1, 2, 4 and 11 explain how architectural decisions are made, documented and governed, and how to discuss trade-offs with technical teams.
AI and machine learning engineers	Take the chapters in order. Chapter 12 shows how models fit into reliable systems; Chapters 2, 6, 7 and 9 cover the qualities, distributed systems, data and resilience that AI products depend on.
Students	The course complements a computing degree with video lessons, worked examples, diagrams and practice tests, and covers topics that degree courses often leave out, such as governance and operations.

What do I need before I start?

No prior knowledge. Chapter 0 explains programs, data, networks, databases, APIs, servers and the cloud before the course turns to architecture. Being able to read a little code helps from Chapter 3 onwards, but you do not need to write any.
A phone, tablet or computer with an up-to-date web browser. You can add the app to your home screen.
An internet connection to read the chapters and watch the video lessons online, take tests and use ArchitectBot. Each chapter can also be downloaded as a PDF to read offline.
Comfortable reading in English. The course is written in British English, with technical terms defined where they first appear and in the glossary.
Time. Most people study a few hours a week; there are no deadlines.

What does the course cover?

The 13 chapters follow a natural order, each building on the ones before, but every chapter can be read on its own.

Chapter 0: Start Here: How Software WorksBeginnerThe groundwork for everything that follows: what a program is, how data and code are organised, how computers talk over networks, where data is stored, what APIs, servers and the cloud are, and how teams build software. No prior knowledge assumed.
Chapter 1: What Software Architecture IsBeginner to intermediateThe definitions that matter (ISO/IEC/IEEE 42010 and the SEI), how architecture differs from design, why it decides cost and risk, what architects actually do, stakeholders, trade-offs, technical debt and where architecture sits in modern delivery.
Chapter 2: Quality Attributes and Architecturally Significant RequirementsIntermediateHow to turn vague wishes like 'fast' and 'secure' into precise, testable requirements: ISO/IEC 25010, quality attribute scenarios, performance, availability, modifiability, security and usability, and how to elicit, prioritise and trade them off.
Chapter 3: Design Principles and FundamentalsIntermediateThe principles behind every good structure: modularity, coupling and cohesion, information hiding, dependency rules, SOLID at component scale, connascence, Conway's law, simplicity and how to measure structure.
Chapter 4: Documenting and Communicating ArchitectureIntermediateViews and viewpoints, the C4 model, the UML that still matters, Architecture Decision Records, arc42, diagrams as code and how to present architecture to technical and non-technical audiences.
Chapter 5: Architectural Styles I: Monoliths and Modular DesignsIntermediateStyles for systems deployed as one unit: layered, modular monolith, pipes and filters, microkernel, hexagonal and clean architecture, domain-driven design, and when a monolith is the right answer.
Chapter 6: Architectural Styles II: Distributed SystemsIntermediate to advancedWhy and when to distribute, the fallacies of distributed computing, service-based and microservice architectures, event-driven systems, synchronous and asynchronous communication, CAP and PACELC, sagas, serverless and space-based designs.
Chapter 7: Data ArchitectureIntermediate to advancedData ownership, choosing a database, transactions and isolation, replication and partitioning, CQRS and event sourcing, caching, schema evolution, and analytics, streaming and data mesh.
Chapter 8: Security, Privacy and Compliance by DesignIntermediate to advancedSecurity principles, threat modelling with STRIDE, identity and access (OAuth 2.0 and OpenID Connect), encryption and secrets, zero trust, software supply-chain security, privacy by design under the GDPR, and security in operation.
Chapter 9: Performance, Scalability, Resilience and OperabilityIntermediate to advancedScaling strategies, load balancing and statelessness, queues and back pressure, timeouts, retries, circuit breakers and bulkheads, SLIs, SLOs and error budgets, observability, capacity planning and chaos engineering.
Chapter 10: Cloud-Native and Infrastructure ArchitectureIntermediate to advancedCloud service models, containers and Kubernetes, the twelve-factor app, infrastructure as code, CI/CD and deployment strategies, multi-region and edge, platform engineering, FinOps and lock-in as a trade-off.
Chapter 11: Evaluation, Decision-Making and GovernanceAdvancedHow architectures are judged and governed: ATAM and lightweight reviews, fitness functions and evolutionary architecture, governance in agile organisations, Team Topologies, legacy modernisation, leadership, ethics and the business case.
Chapter 12: Architecting AI-Enabled SystemsAdvancedMachine learning and large language models from an architect's point of view: where models fit, retrieval-augmented generation, agents and tool use, evaluation, guardrails, cost and latency, LLMOps and responsible AI under the EU AI Act.

See every section of every chapter.

How is the course organised, and how long does it take?

Each chapter opens with a narrated video introduction and an overview: what you will learn, what you should read first, how long it takes and the key terms. It then has eight sections. Every section follows the same pattern:

The video lessonA narrated video of about 4 to 6 minutes that walks you through the section, with English captions, a “Listen only (audio)” option and the full transcript.
The idea in briefA short, simple explanation of the topic, written for a newcomer.
What you need to knowThe key points in a few lines, useful for revision.
The full treatmentProfessional depth, with diagrams, worked examples, tables, decision guides, checklists and, where useful, short code examples.
Check your understandingQuestions with answers to test yourself before moving on.
Sources and related sectionsThe books, standards and papers the section draws on, and links to related parts of the course.

The chapters take about 40 hours to read, roughly two to four hours each. With the chapter tests (about 45 minutes each), the final examination and the case study, the whole course is about 60 hours of study. The 117 video lessons run to about 10 hours in all. It is entirely self-paced: there are no start dates, deadlines or live sessions, and you can stop and return whenever you like.

How do the chapter tests work?

Each chapter has an optional test. You can read the chapter without taking it, and take it whenever you are ready.

The questions20 multiple-choice questions drawn at random from a bank of 64 for that chapter, two or three from each of its eight sections, and 2 short written answers chosen from 8, on different sections. Some multiple-choice questions ask you to choose several answers, to put steps in order or to read a diagram. Because questions are drawn afresh each time, no two attempts are the same.
TimeThere is no countdown. You have 4 hours from starting to submit, and your answers are saved in your browser as you go, so a lost connection or a reload does not lose them.
Written answersEach written question shows the criteria it is marked against, worth 5 marks in total, and a minimum length. Answers shorter than the minimum are not marked, and answers that try to instruct the marker score nothing.
MarkingMultiple choice is marked automatically and is worth 70% of the score. Written answers are marked by an AI marker that applies the published criteria at a fixed setting, so that it marks consistently, and are worth 30%.
PassingYou pass with 80% overall and at least 2 out of 5 on each written answer. Your best score for each chapter is kept.
Your resultIf you pass, you see the correct answer and an explanation for every question you got wrong. If you do not, you see which sections to revise, and you can try again with different questions after 10 minutes. There is no limit on attempts.
Second marking and reportingIf you think a written answer was marked unfairly, you can ask for a second marking within 24 hours; the higher mark counts. If a question seems wrong or unclear, you can report it from the test page and it will be checked.

ArchitectBot is designed to help you understand topics rather than to answer test questions for you, and the written questions ask you to apply ideas rather than repeat them.

What is the final assessment?

When you have passed all 13 chapter tests, the final assessment opens. It has two parts, which you can take in either order.

Part 1: the final examination

60 multiple-choice questions drawn from the whole course, roughly equally from every chapter, to be submitted within 3 hours of starting. The pass mark is 70%. If you do not pass, you can try again with different questions after 24 hours.

Part 2: the architecture case study

You choose one of several realistic briefs, for example a booking platform, a payments service or an AI-assisted support system, and write the architecture you would propose: between 1,500 and 4,000 words. You do not need drawing software: describe your structures in words, lists and tables. The case study is marked out of 50 against this published rubric:

Criterion	Marks	What the marker looks for
Requirements and quality attributes	10	Identifies the stakeholders, constraints and main drivers in the brief, and expresses the most important qualities as measurable, prioritised quality attribute scenarios.
Architectural approach	10	Chooses a style or combination of styles and the main structures, justified against the drivers, with the alternatives considered and the trade-offs stated.
Structure and behaviour	10	Describes the main containers, their responsibilities, the data each owns and how they interact, including at least one important runtime scenario, at the level of a C4 container view.
Cross-cutting concerns	10	Addresses data and consistency, security and privacy, resilience and operability, deployment and cost, and any AI components, each in proportion to what the brief needs.
Decisions, risks and communication	10	Records at least three key decisions as architecture decision records, lists the main risks with mitigations, explains how the design can evolve, and is clear and well organised.
Total	50	Pass: 25 or more, with at least 4 on every criterion.

The case study is marked by an AI marker against the rubric, and you can ask for a second marking. If it does not reach the pass mark, you receive feedback against each criterion and can submit again after 24 hours.

How is the final grade worked out?

Your overall score combines three things: the average of your best scores in the 13 chapter tests (40%), your final examination score (30%) and your case study score as a percentage (30%). Everyone who passes all three parts receives a certificate, graded as follows.

Grade	Requirement
Distinction	Overall score of 90 or more, and at least 80% on the case study
Merit	Overall score of 80 or more
Pass	All chapter tests, the final examination and the case study passed

Worked example

Working out a grade

A learner whose best chapter test scores average 88%, who scores 80% in the final examination and 70% (35 out of 50) on the case study has an overall score of 88 × 0.40 + 80 × 0.30 + 70 × 0.30 = 80.2, which is a Merit.

What does the certificate show, and how can it be checked?

Successful learners receive a Be Wise Certificate of Completion for Be Software Architecture Wise, which you can download as a PDF. It shows:

your name, exactly as you enter it when you claim the certificate (please check it carefully);
the date it was issued;
your grade: Pass, Merit or Distinction;
a unique certificate number, in the form BWSA-2026-ABC123;
a web address where anyone can check it.

Anyone, such as an employer, can enter the number on the certificate check page to see the name, date and grade it was issued with. To make that possible, we keep those details and the number for as long as the certificate is valid. A certificate obtained by impersonation or by submitting someone else’s work may be withdrawn, and a withdrawn certificate shows as withdrawn when checked.

Is the certificate an accredited qualification?

No. The Be Wise Certificate of Completion records that you completed this course and passed its assessments. It is not an accredited qualification, it does not carry academic credit, and it is not issued or endorsed by a university, a professional body, iSAQB, any cloud or software provider, or any author whose work the course cites. The course does not prepare you for, or replace, any external examination.

What it does show is that you worked through a substantial, demanding course and passed 13 chapter tests, a final examination and a written case study. How much weight that carries is a matter for whoever reads it, which is why the certificate can be checked and the full syllabus, rules and rubric are public on this page.

What happens to my data?

No account. You do not need to give a name, email address or password to read the course or take tests.
Reading progress (which sections you have read) is kept only in your own browser.
Test results are kept on our server against a random twelve-character resume code that you receive when you first take a test, with no name or contact details (until you claim a certificate). Enter the code on another device to carry on there. Anyone who has your code can see your scores and continue as you, including claiming your certificate, so keep it private. Scores are kept for two years after your last test, or deleted sooner if you ask.
Your answers to written questions, and your case study, are sent to an AI service to be marked. Do not include personal details in them.
Your name is stored only if you claim a certificate, together with the date, grade and certificate number, so that the certificate can be checked.
ArchitectBot sends your questions to AI and search services to answer them. Do not type personal or confidential information into it.
Analytics cookies are used only if you accept them.

The Be Wise privacy notice explains who we share data with and your rights.

What is ArchitectBot?

ArchitectBot is the course’s AI study assistant. It answers questions about software architecture using the course’s own content first, and searches the web for anything newer. It explains, gives examples and points you to the relevant section. It is not a certified architect, it can make mistakes, and it will help you understand a topic rather than answer a test question for you. Treat its answers as a starting point and check anything important.

How is the content kept accurate and up to date?

Every chapter is written to a published specification, then checked in a separate review against the books, standards, papers and documentation it cites, before it is published. Sources are listed at the end of every section so that you can check them yourself. Every claim is meant to be traceable to a cited source.

Software architecture changes, particularly in cloud and AI, so chapters are updated when practice or standards move on, and each page shows when it was last changed. If you find a mistake, tell us, or report a question from the test page. Later changes to the content never affect a certificate already issued.

Which devices can I use, and is it accessible?

The course works on phones, tablets and computers in any up-to-date browser, and you can install it on your home screen like an app. Every chapter is also available as ordinary web pages and as a downloadable PDF. Every video lesson has English captions, a “Listen only (audio)” option and the full transcript. Diagrams carry text descriptions for screen readers, the pages work with browser zoom and keyboard navigation, and the text uses headings, lists and tables that assistive technology can follow. If something does not work for you, please let us know.

What the course is not

It is educational information, not professional advice. Decisions about real systems depend on facts the course cannot know.
It is not an accredited qualification and not preparation for any external examination.
It is not affiliated with or endorsed by any university, professional body, certification scheme, technology company or cited author.
It is not a coding course: you will read code examples, but the course does not teach a programming language.
It has no live teaching: it is self-study, supported by narrated video lessons and ArchitectBot.

How much does it cost?

The course is supported by clearly labelled advertising. Advertisements never change the content, the questions or the marking.

Questions? Contact us.

Start with Chapter 0 Browse the chapters

Course contents

Every chapter and section

All thirteen chapters are open to read. Search across titles, summaries and the glossary. New to software? Follow the path for beginners. Already work with software? Follow the route for experienced learners.

Glossary

Terms used in the course

Short definitions of the terms used across the chapters. Tap any underlined term in a section to see its definition without leaving the page.

ArchitectBot

Ask about software architecture

ArchitectBot is an AI study assistant. It answers from this course first and checks the live web for anything newer. It can be wrong, so treat its answers as a starting point.

Educational information, not professional advice. ArchitectBot can make mistakes.

Advertise

Advertise on Be Software Architecture Wise

Reach people learning software architecture: developers moving into architecture, engineering managers, students and AI engineers. Banner spaces are available on the home page and on chapter pages for training providers, certification bodies, developer tools, cloud services and recruiters.

Advertisements are clearly labelled. They never change the content of the course, the questions in the tests or how answers are marked.