Learning paths
The platform renders your architecture. The Academy teaches you how to decide it.
Six paths through software architecture, from what the discipline actually decides to what the next change will cost. Built around the same principles the platform holds designs to, so what you learn here is what is checked there.
In preparation.The curriculum below is settled; the lessons are still being written, and there is nothing to enrol in yet. Every path links to the documentation that covers its ground today.
Told as stories
Architecture is taught badly as a list of definitions and well as a sequence of decisions someone had to live with. So the lessons carrying astorymark come with a short video in narrative form: a team with a problem, the option they took, what it bought them and what it cost. 12 of the25 lessons are planned that way — the rest are short enough to read.
The curriculum
- FoundationComing soon
What architecture actually decides
Before any notation: which decisions belong to architecture, which do not, and why the expensive ones are the ones that are hard to reverse.
- The decisions that are costly to change — and the ones that are not Includes a storytelling video
- Quality attributes: naming the -ilities that matter for this system
- Every choice buys something and pays for it somewhere else Includes a storytelling video
- Writing the decision down: the architecture decision record
Read today: Overview
- CoreComing soon
Design patterns
The catalogue every architect is assumed to know, taught the way it is actually used: as a shared vocabulary for a problem you already have, not a shelf to shop from.
- Creational, structural, behavioural — what each family is really for Includes a storytelling video
- Patterns of enterprise application architecture: layers, mappers, units of work
- Integration patterns: messaging, routing, transformation, and the fallacies underneath Includes a storytelling video
- Anti-patterns — the ones that look like patterns until the second year
- When not to use a pattern, and how to tell Includes a storytelling video
Read today: Sustainable design
- CoreComing soon
Modelling a domain
Domain-Driven Design in the two halves that matter: where the boundaries go, and what lives inside one. The vocabulary the other landscapes are organised around.
- Bounded contexts: finding the seams that are already there Includes a storytelling video
- Context maps and the relationship patterns on each edge
- Aggregates, entities, value objects — and why the distinction pays
- Ubiquitous language: when the same word means two things Includes a storytelling video
Read today: The landscapes
- CoreComing soon
Architecture as code
Keeping the model in version control and generating the views from it, so a diagram cannot quietly stop being true.
- Why the drawing drifts, and what it costs when it does Includes a storytelling video
- One model, many views: C4 at four zoom levels
- Generating diagrams in the pipeline instead of drawing them
- Reviewing a model change like a code change
Read today: Architecture as code
- AppliedComing soon
Contracted design
Making the interface between two parts explicit enough that either side can change without asking permission — the discipline api-hub scores.
- API-first: the contract before the implementation Includes a storytelling video
- What belongs in a contract, and what is an implementation detail
- Consumer-driven contracts and the tests that come with them
- Versioning and deprecation without breaking the people downstream Includes a storytelling video
Read today: Contracted design
- AdvancedComing soon
Designing for change
The honest measure of an architecture is what the next change costs. Coupling, testability at the seams, and keeping a design refutable.
- Coupling and cohesion, measured rather than asserted Includes a storytelling video
- Testing at the boundaries instead of around the whole system
- Fitness functions: a build that fails when the architecture erodes Includes a storytelling video
- Evolutionary architecture — deciding late, on purpose
Read today: Testable design
You do not have to wait
Every principle the first lessons will teach is already written down, and the fastest way to learn how the models fit together is to open the landscapes and follow one system through all of them.