Platform Engineering · Lesson 190

Software Architecture Foundations: What Architecture Is, and How to Prove It

A feature request lands on my desk. Someone wants the order page to show a discount. That sounds like one line of code. It is not. It is a question about where the discount lives, who else reads it, what breaks when the rule changes, and who decided any of it. That question is architecture. System design is the name the industry gives to this work: choosing the shape of a system before you build it, and writing down why you chose it. This lesson walks one request through that work, from the first question to the shipped change. I show the five SOLID rules, test-driven development, domain-driven design, the MVC family, and the decision record that keeps it all honest.

Difficulty: Intermediate · Know this first: Lesson 154, Lesson 27, Lesson 26

What you will build

By the end of this lesson you will have proved one small design four ways, and you will have the tools to prove the next one. First, an OOP bridge script that names the four words behind the login lab: class, inheritance, encapsulation, and polymorphism. Second, an order total with its discount behind a policy interface, covered by four tests you wrote first. Third, a decision record for that discount, ADR-001, with all four parts. Fourth, a lint script that reads a decision record and fails when a part is missing. You will also know the three levels of architecture, and which level an argument is really about.

What you need: Python 3 on your own machine. Nothing in this lesson runs against a live system from this page. The Python parts run on this machine and their outputs are shown exactly as they ran.

The story: one discount, nine hops, one record

The Python labs already taught the four OOP words by doing, without naming them much. Lesson 154 builds a login checker from classes. Here are the names, using that lab's shape: a base class called Check, two kinds called HttpCheck and PingCheck, and one loop that calls run() on both kinds. A class is a kind of thing with data and behaviour. Inheritance is a subclass taking the base class's shape: the subclasses take name and _last from Check. Encapsulation is the base class keeping _last behind the status property, so outside code reads it but does not write it. Abstraction is the base class refusing to run, so every subclass must say how it runs. Polymorphism is the one loop: it calls run() on both kinds, and each kind answers in its own way. Add a third kind and the loop does not change. That loop is the whole reason the base class exists, and it is the seed of everything in this lesson.

Architecture works at three levels, and the first thing I check when a design argument goes in circles is which level the two sides are arguing at. The table is the whole map on one page. Read it top to bottom, then walk the diagram hop by hop.

LevelThe question it answersWhat lives hereWho owns it
ApplicationHow is one program shaped inside?Classes, modules, where one rule livesThe team that writes the code
SolutionHow does one system fit together?Services, data, boundaries between teamsThe teams that share the system
EnterpriseWhat must every system do the same way?Shared rules, shared platforms, decision recordsThe whole company

A change that is cheap at the application level can be expensive at the solution level, and a decision that is right for one team can be wrong for the whole company. The discount in this lesson starts at the application level: one class, one rule. It moves to the solution level the moment a second team needs its own discount. It reaches the enterprise level the moment the company says no team edits the shared total. The levels are not a ladder you climb once. They are three lenses you hold up to every decision, and the decision is only done when it reads clean through all three.

The five SOLID rules are the application level in checklist form. The MVC family is the solution level for one screen. Domain-driven design is the solution level for the words the business uses. Test-driven development is the proof at every level: a test is a requirement a machine can run. The decision record is the memory at every level: a file with four parts that says why it is built this way. Governance is the gate that reads the record. The diagram below walks one request through all of it, in order.

Do this now, before the diagram

Open the login lab from Lesson 154 and find the Check base class. Read the run() method that refuses, and the status property that reads _last. Write down, in your own words, what inheritance gives HttpCheck, what encapsulation hides, and what the loop never asks. Three sentences. If you cannot write them, run the lab again and read the output line by line. The rest of this lesson is those three sentences, grown up.

Run it as:

When it breaks, I check

One thing to remember

Four paths, one family

The diagram above follows one question through the AI design. These four paths are the same idea drawn four ways. One question, answered. One question, blocked. One dollar trail, hop by hop. One afternoon at peak, mostly waiting. Run each path. One run takes 7.2 seconds across the path, so you can watch each hop light up in turn.

The return rule: the green dot only starts moving after the orange dot reaches the data hop. A return with no request is a lie. The diagram never draws one. The failure replay at the end of Run all four shows the other side of the rule. Run it and watch the orange dot stop at the page and never come back.

Path 1: the clean feature

Debt trail: skipped

One feature request walks the architecture work from hop 1 to hop 9. Every hop proves its part, and the last hop ships the change with four tests green and ADR-001 accepted.

Request0 ms
Elicit30 ms
Boundaries25 ms
Pattern20 ms
SOLID35 ms
Tests40 ms
ADR15 ms
Governance20 ms
Ship25 ms

Not run yet.

Path 2: the rushed feature

Tests: skipped

Same request, shipped fast. No boundary, no SOLID check, no tests, no record. The request reaches the ship hop, the deploy breaks, and the page fires. The dot stops at the page and never comes back.

Request0 ms
Elicit10 ms
Pattern10 ms
Testsskipped
Ship25 ms
On-call pagefail

Not run yet.

Path 3: the test trail

Governance: skipped

The same design, counted in tests instead of milliseconds. Each hop shows how many tests of that kind guard the discount. The trail adds up to 175 tests. The end-to-end hop is the data hop: it is the test that proves the whole trip.

Unit120
Integration35
Contract12
End-to-end8

Not run yet.

Path 4: the review load

Peak traffic: skipped

The same request at review time. Each hop shows how busy that part of the review is. Governance is the busiest hop at 80 percent, because four old decisions have no record. The ship hop is the quietest, because the work was done before it.

Elicit40%
Boundaries25%
Pattern30%
Tests65%
Governance80%
Ship20%

Not run yet.

Where the time goes

Every hop charges rent in milliseconds. The bar below is a worked example for one feature request through the architecture work, not a measurement from a live system, but the shape is honest. The tests hop is the big one. It costs 40 ms at the simulator defaults, and the SOLID hop costs 35 ms. The other hops are asking, drawing, and writing down. Switch the scenario and watch the bar change. In the rushed story four hops disappear, because a rushed trip writes no boundary, no SOLID check, no tests, and no record. In the muddy story every hop grows, because the old code charges rent on every hop. Move a simulator slider and watch the boundaries hop, the SOLID hop, the tests hop, and the governance hop move with it.

How big is the module: move the sliders and watch the design time

The budget bar above shows three fixed stories. This simulator lets you write your own. It answers the trade-off at the heart of this lesson: the bigger the module, the more coupled it is, and the less it is tested, the more every change costs. You set how many classes the module holds, how many dependencies each class carries, how much of it the tests cover, and how many developers work on it. Move a slider and watch the boundaries hop, the SOLID hop, the tests hop, and the budget total change. The numbers are a teaching example, built from the formulas below, not live measurements. The shape is the lesson: size times coupling times untested share is the price of the next change.

40 classes

How many classes the module holds. More classes means more SOLID work on the Apply SOLID hop.

3 per class

How many other classes each class depends on. More dependencies means more untangling on the SOLID hop.

70%

How much of the module the tests cover, in percent. Less coverage means more test-writing time on the Write the tests hop.

4 developers

How many developers work on this module. More developers means more boundaries to agree on and more governance to check.

Try this: (1) At the defaults, 40 classes, 3 dependencies per class, 70 percent coverage, 4 developers, the boundaries hop is 25 ms, the SOLID hop is 35 ms, the tests hop is 40 ms, and the governance hop is 20 ms. The budget total is 210 ms and the change cost index is 36. (2) Shrink to a small clean module: 10 classes, 1 dependency, 95 percent coverage, 2 developers. The boundaries hop falls to 19 ms, the SOLID hop to 10 ms, the tests hop to 15 ms, and the governance hop to 14 ms. The budget total is 148 ms and the change cost index is 0.5. (3) Grow to a big ball of mud: 200 classes, 10 dependencies, 0 percent coverage, 12 developers. The boundaries hop grows to 49 ms, the SOLID hop to 150 ms, the tests hop to 110 ms, and the governance hop to 44 ms. The budget total is 443 ms and the change cost index is 2000. From the defaults, the mud costs 233 ms more per change and a change cost index 55 times higher. That is the trade, priced.

Formulas, in plain terms. Draw boundaries hop = 13 ms plus 3 ms per developer. Apply SOLID hop = 5 ms plus 0.5 ms per class plus 5 ms per dependency past the first. Write the tests hop = 10 ms plus 1 ms per uncovered percent, which is 100 minus coverage. Check governance hop = 8 ms plus 3 ms per developer. Budget total = 0 plus 30 plus boundaries plus 20 plus SOLID plus tests plus 15 plus governance plus 25. Change cost index = classes times dependencies times uncovered percent, divided by 100. The index is a teaching model, not a measurement. The shape is the lesson: size times coupling times untested share is the cost of the next change.

Lab: prove the design yourself

Do this now, on your own machine. You will name the four OOP words with a script, prove the SOLID discount with tests you wrote first, write a decision record, and lint it. The Python parts run on this machine and their outputs are shown exactly as they ran.

Step 0: name the four OOP words

Save this file as oop_bridge.py. It is the login lab's shape with new names: one base class, two kinds, one loop that never asks the kind. The comments name the four words. Run it and read the output.

"""OOP terms bridge: the four words behind the login lab.

The login lab in Lesson 154 taught these by doing, without naming
them much. This file names them, using the same shape: one base class,
two kinds, one loop that never asks the kind.

- A class is a kind of thing with data and behaviour.
- Inheritance is a subclass taking the base class's shape.
- Encapsulation is the base class keeping its own state private.
- Polymorphism is one loop calling run() on every kind.
- Abstraction is the base class refusing to run, so each kind must
  say how it runs.
"""

class Rule:
    """One check on a password. The base class refuses to run."""

    def __init__(self, name):
        self.name = name
        self._last = "not run"

    def run(self, value):
        raise NotImplementedError("every rule must say how it runs")

    @property
    def status(self):
        return self._last


class LengthRule(Rule):
    def run(self, value):
        self._last = "pass" if len(value) >= 8 else "fail"
        return self._last


class DigitRule(Rule):
    def run(self, value):
        self._last = "pass" if any(c.isdigit() for c in value) else "fail"
        return self._last


def check_all(rules, value):
    problems = []
    for rule in rules:
        rule.run(value)
        print(f"{rule.name} -> {rule.status}")
        if rule.status == "fail":
            problems.append(rule.name)
    return problems


if __name__ == "__main__":
    rules = [LengthRule("at least 8 characters"), DigitRule("one digit")]
    print("password: Sunrise")
    problems = check_all(rules, "Sunrise")
    print("problems:", problems)
    print("password: Sunrise9")
    problems = check_all(rules, "Sunrise9")
    print("problems:", problems)
python3 oop_bridge.py

Expected output, exactly as it ran on this machine:

password: Sunrise
at least 8 characters -> fail
one digit -> fail
problems: ['at least 8 characters', 'one digit']
password: Sunrise9
at least 8 characters -> pass
one digit -> pass
problems: []

Read the output against the four words. The loop calls run() on both kinds and never asks what kind a rule is. That is polymorphism. The base class refuses to run. That is abstraction. The subclasses take name and _last from Rule. That is inheritance. The status property reads _last, and nothing outside the class writes it. That is encapsulation.

Step 1: write the test first, then the discount

Save this file as solid_tdd.py. The test functions come first in the file on purpose. That is test-driven development: write the test, watch it fail, write the smallest code that passes. The Order class has one job. The discount is a policy object behind a small interface, so a new discount kind never touches Order.

"""SOLID and TDD in one small file: pricing an order.

The test functions come first in the file on purpose. That is TDD:
write the test, watch it fail, write the smallest code that passes.
The Order class has one job (add up the lines). The discount rule is
a separate object behind a small interface, so a new discount kind
never touches Order. That is the Open/Closed Principle and the
Dependency Inversion Principle doing their ordinary jobs, and the
Single Responsibility Principle is the Order class staying small.

Run it: python3 solid_tdd.py
"""


class DiscountPolicy:
    """Interface: a discount answers one question, how much off."""

    def discount(self, subtotal):
        raise NotImplementedError("every discount must say how much off")


class NoDiscount(DiscountPolicy):
    def discount(self, subtotal):
        return 0


class TenPercentOver100(DiscountPolicy):
    def discount(self, subtotal):
        return subtotal * 0.10 if subtotal >= 100 else 0


class Order:
    """One job: add up the lines, then ask the policy for the discount."""

    def __init__(self, policy):
        self.policy = policy
        self.lines = []

    def add(self, price, qty=1):
        self.lines.append(price * qty)

    def total(self):
        subtotal = sum(self.lines)
        return round(subtotal - self.policy.discount(subtotal), 2)


def test_no_discount():
    order = Order(NoDiscount())
    order.add(40)
    order.add(30, 2)
    assert order.total() == 100, order.total()


def test_small_order_gets_no_ten_percent():
    order = Order(TenPercentOver100())
    order.add(50)
    assert order.total() == 50, order.total()


def test_big_order_gets_ten_percent():
    order = Order(TenPercentOver100())
    order.add(60, 2)
    assert order.total() == 108, order.total()


def test_new_policy_needs_no_order_change():
    order = Order(TenPercentOver100())
    order.add(200)
    assert order.total() == 180, order.total()


if __name__ == "__main__":
    for test in (test_no_discount, test_small_order_gets_no_ten_percent,
                 test_big_order_gets_ten_percent,
                 test_new_policy_needs_no_order_change):
        test()
        print(f"PASS {test.__name__}")
    print("4 tests passed")
python3 solid_tdd.py

Expected output, exactly as it ran on this machine:

PASS test_no_discount
PASS test_small_order_gets_no_ten_percent
PASS test_big_order_gets_ten_percent
PASS test_new_policy_needs_no_order_change
4 tests passed

Now break it on purpose. Change TenPercentOver100 to return 0.20 instead of 0.10 and run it again. test_big_order_gets_ten_percent fails, and the other three still pass. The failing test names the exact rule that broke. That is the point of the test: it is the requirement, written in a form a machine can run. Change it back when you are done.

Step 2: write the decision down, then lint it

Save this file as adr-001.md. It has the four parts every decision record needs: status, context, decision, consequences.

# ADR-001: The order total reads its discount from a policy object

## Status

Accepted

## Context

The order total used to hold the discount rule inside itself. Every
new discount kind meant editing the Order class, and every edit risked
the total. Two teams now sell through the same order code, and each
team wants its own discount rule.

## Decision

Order keeps one job: add up the lines. The discount rule lives in a
separate object behind the DiscountPolicy interface. Order asks the
policy how much off, and never asks what kind of discount it is. A new
discount kind means a new policy class, not a change to Order.

## Consequences

Good: a new discount ships without touching the total, and the total
stays covered by the same four tests. Bad: a reader must open two
files to see the whole price, and a policy with a bug looks like a
total with a bug until the tests say which one it is.

Save this file as adr_lint.py. It reads one ADR file and fails loudly when a part is missing, so a half-written decision never passes review.

"""ADR lint: a decision record is only useful if it can be read later.

An ADR must name its status, its context, its decision, and its
consequences. This script reads one ADR file and fails loudly when a
part is missing, so a half-written decision never passes review.

Run it: python3 adr_lint.py adr-001.md
"""
import sys

REQUIRED = ["## Status", "## Context", "## Decision", "## Consequences"]


def lint(path):
    text = open(path, encoding="utf-8").read()
    missing = [h for h in REQUIRED if h not in text]
    for heading in REQUIRED:
        print(f"[{'PASS' if heading not in missing else 'FAIL'}] {heading}")
    if missing:
        print(f"FAIL {path}: missing {', '.join(missing)}")
        return 1
    print(f"PASS {path}: all four parts present")
    return 0


if __name__ == "__main__":
    sys.exit(lint(sys.argv[1] if len(sys.argv) > 1 else "adr-001.md"))
python3 adr_lint.py adr-001.md

Expected output, exactly as it ran on this machine:

[PASS] ## Status
[PASS] ## Context
[PASS] ## Decision
[PASS] ## Consequences
PASS adr-001.md: all four parts present

Now break it on purpose. Delete the Consequences section from adr-001.md and run the lint again. It fails on that one part and names it. A decision with no consequences section is a decision nobody thought through. Put the section back when you are done.

Check yourself

Add a third discount policy class to solid_tdd.py, one that takes 5 off any order over 50, and add a test for it. Run the tests. The Order class must not change. If you had to edit Order, the design is wrong: the policy is the extension point, and the total is closed to modification. Then write ADR-002 for the new policy, run the lint on it, and check all four parts pass.

Clean up

Nothing to destroy. The four files live on your machine, and you can run them again on the next design. Keep ADR-001. It is the first record in a habit that pays for itself every time a new engineer asks why it is built this way.

Check yourself

Three questions. No score is saved anywhere. This is just you against the material.

Basic to master

Software architecture is not one skill. It is four levels of the same job, and every team I have worked with sits on one of them. The levels are not about how many patterns you can name. They are about whether the design holds when the next change arrives. Read them in order. Each level fixes the failure that hurt the most at the level below it.

Basic · One class, one job

At the basic level, you run the lab. You read the Order class and you name its one job. You run the four tests. You write ADR-001 and you run the lint on it. The failure that ends this level is the second class. One clean class feels like architecture. It is not. It is a start.

Do this: run step 1 of the lab, then add a second discount policy class and run the tests again. The Order class does not change. Then run step 2 and check the lint passes on your ADR.

Intermediate · The patterns, used on purpose

At the intermediate level, the patterns are chosen, not inherited by habit. MVC on one screen, with the rule written down: the view never calls the database. DDD on one boundary, with the words named and one owner per context. A test for every rule, written first. The failure that ends this level is the second team. One team's clean design meets another team's words, and the boundary is where it breaks.

Do this: draw the boundary for one feature you own. Name the words each side owns. Write the one-sentence requirement for it, and read it back to the person who asked for the feature.

Advanced · Trade-offs, written down per level

At the advanced level, every trade-off is written down, and it is written down per level. The application level trades simplicity for speed: one class is simple, five policy classes are flexible. The solution level trades independence for consistency: each team owns its rule, and the total is the one thing nobody owns alone. The enterprise level trades team freedom for shared rules: every decision gets a record, every secret lives in the vault. Each trade goes in an ADR, with all four parts.

Do this: write an ADR for a decision you made last month, with all four parts, and run the lint script on it. If the consequences section is empty, the decision was not thought through. Fill it in honestly.

Master · Governance as code

At the master level, governance is a test, not a document. The ADR lint runs in CI on every change. A decision without a record fails the build. A class with two jobs fails review, and the review points at the test that proves it. The team still holds a review every quarter. The review reads the gate history. It does not start from zero.

Do this: write one lint rule for one governance rule you care about, and run it in CI on one repository. A rule nobody checks is a suggestion. A rule in CI is a gate.

Go deeper

The levels argue with each other

A decision that is right at one level can be wrong at another, and that is where most architecture arguments actually live. At the application level, putting the discount in the Order class is the simplest code. One class, one file, done by lunch. At the solution level it is wrong, because the second team cannot add its own discount without editing the first team's class. At the enterprise level it is worse, because the shared total is the one thing no team should edit alone. When an argument goes in circles, I ask which level each side is arguing at. The answer is usually two different levels, and the fix is to name the level before you argue the decision.

SOLID at 10x

At ten times the classes, the SOLID hop is the number to watch. The simulator says a 200-class module with 10 dependencies per class costs 150 ms on that hop, against 35 ms at the defaults. The fix is not a bigger refactor at the end. The fix is splitting before it grows: one new policy class per discount, one bounded context per team, and a test that fails the moment a class takes a second job. A god class is not born big. It grows one small edit at a time, and every edit felt reasonable on the day it was made.

TDD at 10x

At ten times the tests, the suite is the contract, and a slow suite is a suite nobody runs. The tests hop in the muddy scenario costs 120 ms because every test builds the whole god class first. The fix is the same as the SOLID fix: small classes make small tests, and small tests run fast. A test suite that takes ten minutes is a suite the team runs once a day. A suite that takes ten seconds is a suite the team runs on every change. The speed of the suite is the speed of the team.

DDD at 10x

At ten times the teams, the bounded contexts become services, and the translation between them becomes the API contract. The word customer means the person who pays on one side and the company that signs on the other, and the translation is where the two meet. That translation is a real piece of code, with its own tests, not a comment in a meeting note. The context map is the diagram of who talks to whom, and it is the first diagram I draw when a new team joins.

The ADR is a living record

A decision record is never rewritten. When a decision changes, I write a new ADR that names the old one and says what changed. ADR-002 supersedes ADR-001. The old record stays, because the old decision was right for the old facts, and the history is the lesson. A record that is rewritten is a history that is lost. The lint script below is the gate that keeps the record honest: it reads a file and fails when a part is missing.

"""ADR lint: a decision record is only useful if it can be read later.

An ADR must name its status, its context, its decision, and its
consequences. This script reads one ADR file and fails loudly when a
part is missing, so a half-written decision never passes review.

Run it: python3 adr_lint.py adr-001.md
"""
import sys

REQUIRED = ["## Status", "## Context", "## Decision", "## Consequences"]


def lint(path):
    text = open(path, encoding="utf-8").read()
    missing = [h for h in REQUIRED if h not in text]
    for heading in REQUIRED:
        print(f"[{'PASS' if heading not in missing else 'FAIL'}] {heading}")
    if missing:
        print(f"FAIL {path}: missing {', '.join(missing)}")
        return 1
    print(f"PASS {path}: all four parts present")
    return 0


if __name__ == "__main__":
    sys.exit(lint(sys.argv[1] if len(sys.argv) > 1 else "adr-001.md"))

Run it in CI on every ADR file in the repository. A decision without a record fails the build, and a record without consequences fails the build too. The gate is small. The habit it builds is the whole lesson.

What changes at 10x and 100x

At 10x the teams, the enterprise level stops being a document and becomes a platform team. The shared rules get owners, the lint scripts get a repository, and the review gate gets a dashboard. At 10x the decisions, the ADR folder needs an index: one page that lists every decision, its status, and the ADR that superseded it. At 100x, the architecture gets a person. The architect reads the gate history every week, and the review reads the architect. The framework does not change. The number of people reading it does.

Further reading

Robert C. Martin, Agile Software Development, Principles, Patterns, and Practices, for the SOLID rules as they were first written. Eric Evans, Domain-Driven Design, for bounded contexts and the language of the business. Kent Beck, Test-Driven Development: By Example, for the red, green, refactor loop. Michael Nygard, Documenting Architecture Decisions, for the ADR format this lesson uses. Four books, each one short enough to read in a week, each one worth the week.

One time it broke

What broke

A discount shipped without a test and without a record. The rule lived in the order total. A second team needed a different discount for their customers, so they edited the same class. The edit changed the total for the first team too, and nobody knew, because no test covered the total and no record said who owned the rule.

Timeline

  • 09:00The edit ships. The discount rule changes in the order total.
  • 09:40The first team reports wrong totals on their orders.
  • 10:15The dashboard shows the totals are wrong. I blame the data.
  • 11:00The data is fine. I blame the deploy, then the cache.
  • 11:45I open the Order class. It holds the total, the discount, and the email.
  • 12:00I read the history. The discount rule changed that morning, in the same class, by the second team.
  • 12:30The discount moves into a policy object, the test for the total goes in first, and ADR-001 is written.

What changed after

Two things. First, the rule. A class holds one job, and a new discount is a new class. Second, the record. Every decision gets an ADR the day it is made, and the lint runs in CI. The class is still small. The record is why it stayed small.

If you remember nothing else

Design exercise

Design the discount system for a shop with three teams, each with its own discount rule, one shared order total, and a monthly change rate of one new rule per team. The total must never break when a team adds a rule. Name the levels, draw the boundaries, pick the pattern, and say what you record.

Clarifying questions to ask

  • What does each team's discount depend on: the customer, the order size, or the season?
  • Who owns the order total, and who is allowed to change it?
  • What happens when two discounts apply to one order?
  • How does a new team join without editing the total?

Worked approach

Start with the levels. The application level is the Order class with one job. The solution level is the boundary between the order context and each discount context. The enterprise level is the rule that no team edits the total. Name the level before you argue the decision, or the argument goes in circles.

Then the boundaries. One bounded context per team discount, one for the order total, and a translation where they meet. The word customer means the person who pays on one side and the company that signs on the other, so the translation is a real piece of code with its own tests, not a comment in a meeting note.

Then the pattern. MVC on the order screen. The model holds the total, the controller asks the policy, the view shows the answer. The view never calls the database, and the controller never computes the total.

Then SOLID and TDD. Each discount is a policy class behind the DiscountPolicy interface, so a new rule is a new class and the total is closed to modification. A test per rule, written first, and a test that two discounts combine the way the requirement says. One new rule a month per team is twelve new classes a year, and not one edit to Order.

Then the record. One ADR per boundary decision, with all four parts, and the lint runs in CI. When a decision changes, a new ADR supersedes the old one. The old record stays, because the history is the lesson.

Trade-offs to name. Independence versus consistency is the big one. Each team owns its rule, and the total is the one thing nobody owns alone. Speed versus safety is the second. A new rule ships fast, and the test suite is what makes fast safe. Simplicity versus flexibility is the third. One interface, many policies, and the interface is the contract that must not change. Name all three before you build.

Saved in this browser, so the Lessons index can show your progress across the course.

Next in this series: Lesson 191, Frontend for Platform Engineers
Frontend for Platform Engineers

The design now has a shape. The next lesson builds the part the user actually touches: the screen. HTML and CSS by hand, then JavaScript, then React, and the question of where the view ends and the model begins.

Go to Lesson 191 →

Or browse the full course from the Lessons index.