Platform Engineering · Lesson 222

Portfolio & Interviews

A portfolio is not a list of projects. It is one project a stranger can run, check, and believe in ten minutes. This lesson builds that project. It is a small triage assistant. It reads an alert, finds the runbook page, and answers with sources. It runs on this machine. No model call. No API key. Then the lesson turns the project into interview answers. You walk a stranger through the same nine hops, live, under a clock, and you say what you would change next. The candidates who get hired are not the ones with the most projects. They are the ones with one project they can defend.

Difficulty: Advanced · Know this first: Lesson 215, Lesson 195

What you will build

Four things, and you keep all four. First, triage.py, a small assistant that reads an alert and answers with runbook sources. Second, eval.py, a 3-case eval set that proves it works. Third, a README with four sections. Fourth, a 60-second interview answer and five mock questions with answers. Everything runs on this machine. Nothing calls a model. Nothing needs a key.

The story

Meera is a fresher. She finished a triage project on a Sunday night. It read an alert, found the runbook page, and printed an answer. It worked. She sent forty applications. She got two replies.

The first interview lasted twenty minutes. The interviewer opened the repo and asked one question. How do you know it works. Meera ran the demo. It worked. He asked again. How do you know it works on the tenth alert, not just this one. She had no answer. No evals. No README. No write-up. No offer.

She did not rebuild the project. She added three things. A README that says how to run it. An eval set with three cases. A one-page write-up with one trade-off. The second interview used the same project and the same demo. The interviewer ran the evals himself. He asked about the trade-off. She answered in one minute. Offer.

She did not change the project. She changed the proof around it. That is this lesson.

Run it as:

When it breaks, I check

One thing to remember

Where the time goes

Every hop charges rent in milliseconds. The bar below is a worked example for one interview question, not a measurement from a live system, but the shape is honest. On the normal path, writing the answer is more than half of the trip, and retrieval is the next biggest slice. The check and the verdict are the cheapest hops. Step through the lesson or switch the scenario and watch the bar change. The weak path is the slowest, because it scans files by hand and writes a hedged answer. The interview path is almost as slow, because the answer is written twice.

Score your own portfolio, and watch the verdict move

The budget bar above shows three fixed stories. This simulator lets you write your own. It answers one question: how strong is the evidence behind your project. You set the eval cases, the retrieved chunks, the answer length, and the mock interviews you have done. Move a slider and watch the evidence score, the total time, and the verdict change. The numbers are a teaching example, built from the formulas below, not live measurements. The shape is the lesson: evals are the cheapest proof you can buy, and a thin answer costs more time than a short one.

README 4 sections, one command Live demo python3 triage.py Eval set 3 cases, 3 of 3 pass Interview answer, 60 seconds one number, one trade-off, one next step One link. One command. One number.
20 cases

Cases with an expected answer, written down before the run. Zero means the demo is the only proof. Twenty is a real set. Fifty is a set you maintain.

5 chunks

Pages fetched at hop 2, 400 tokens each. Zero means the answer comes from the alert alone, with no runbook behind it. Ten is a long context and a slow read.

150 words

Words in the written answer. Fifty is terse. One hundred fifty is one paragraph. Three hundred is hedging, and the time shows it.

3 mocks

Full run-throughs out loud, with someone asking questions. Zero means the interview is the first time you say any of this. Three is enough to find the stall. Ten is polished.

Try this: (1) Set the eval cases to 0. The evidence score falls from 75 to 35, and the verdict flips to weak. The demo still works. The proof is gone. (2) Push the answer length to 300 words. The write hop goes from 950 ms to 1,599 ms, and the trip takes 2,219 ms. Same facts, 649 ms slower. The extra words bought nothing. (3) Set the eval cases to 50 and the chunks to 10. The score hits 100 of 100, and the trip takes 1,780 ms. Full marks on paper. Now ask whether fifty cases measure anything new, or the same three cases written seventeen ways.

Formulas, in plain terms. Score hop ms = 20 + eval cases x 2. Retrieve ms = 60 + chunks x 30. Write ms = 300 + words x 4.33. Demo ms = 156 - mocks x 12, floored at 60. Total time = check 15 + retrieve + extract 95 + score + write + ground 80 + demo + verdict 40. Evidence score = evals x 2 (capped at 50) + chunks x 3 (capped at 30) + 15 for 3 or more mocks + 5 when the answer stays under 200 words. Model cost is $0.00. The demo runs on this machine with no model call, so the bill is the lesson: the proof is free, the waiting is not. Moving a slider updates the hop timings, the budget bar, and the step panel above.

Lab: build the portfolio project

Do this now, in your own terminal. You will write four files, run the tool, watch the evals fail once, fix the failure, and end with a README that passes its own check. The tool is a keyword match plus one threshold guard. No model is called. No API key. The shape is what matters, and the shape is production shape.

Step 1: make the folder and the runbook

The runbook is three pages. Each page has an id, the keywords that match it, a title, and the action it tells you to take. Save this as runbook.json.

{"entries": [
  {"id": "RB-01", "keywords": ["checkout", "latency"], "title": "Checkout latency is high", "action": "Check the checkout queue depth first. If p95 stays above 800 ms for 5 minutes, roll back the last deploy."},
  {"id": "RB-02", "keywords": ["checkout", "error rate"], "title": "Checkout errors are up", "action": "Check the payment dependency first, then read the checkout service logs."},
  {"id": "RB-03", "keywords": ["deploy"], "title": "A deploy just finished", "action": "Compare the deploy diff with the previous version before any rollback."}
]}

Step 2: write triage.py, version one

Save this as triage.py. It reads the alert, matches keywords, and prints the answer with sources. Version one has no threshold guard. That is on purpose. The evals in step 4 will catch it.

"""v1 of the triage assistant: keyword match only, no threshold guard.
Used only to prove the eval failure in the lesson lab (case 3 FAILS)."""
import json
import re
import sys


def load_runbook(path="runbook.json"):
    with open(path) as f:
        return json.load(f)["entries"]


def analyze(text, entries):
    low = text.lower()
    m = re.search(r"p95 latency (\d+) ms, threshold (\d+) ms", text)
    p95 = int(m.group(1)) if m else None
    threshold = int(m.group(2)) if m else None
    matched = [e for e in entries
               if all(k in low for k in e["keywords"])]
    return {"p95": p95, "threshold": threshold, "matched": matched}


def report(text, entries):
    r = analyze(text, entries)
    lines = ["ALERT: " + text.strip().splitlines()[0]]
    if r["p95"] is not None:
        lines.append("FACT: p95 is %d ms, threshold is %d ms"
                     % (r["p95"], r["threshold"]))
    if not r["matched"]:
        lines.append("NO MATCH: no runbook entry fits this alert. "
                     "Escalate to a human.")
        return lines
    for e in r["matched"]:
        lines.append("MATCHED: %s - %s" % (e["id"], e["title"]))
    lines.append("ANSWER: " + " ".join(e["action"] for e in r["matched"]))
    lines.append("SOURCES: " + ", ".join(e["id"] for e in r["matched"]))
    return lines


def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "alert.txt"
    with open(path) as f:
        text = f.read()
    for line in report(text, load_runbook()):
        print(line)


if __name__ == "__main__":
    main()

Step 3: write the alert and run it

Save this as alert.txt, then run the tool.

2026-11-21T09:14:02Z checkout p95 latency 3100 ms, threshold 800 ms
2026-11-21T09:14:05Z deploy checkout v2.14.3 finished 09:12:44Z
python3 triage.py

Expected output, exactly as it ran in this build:

ALERT: 2026-11-21T09:14:02Z checkout p95 latency 3100 ms, threshold 800 ms
FACT: p95 is 3100 ms, threshold is 800 ms
MATCHED: RB-01 - Checkout latency is high
MATCHED: RB-03 - A deploy just finished
ANSWER: Check the checkout queue depth first. If p95 stays above 800 ms for 5 minutes, roll back the last deploy. Compare the deploy diff with the previous version before any rollback.
SOURCES: RB-01, RB-03

Read the last line first. The answer cites its sources. That line is the whole portfolio. Everything else in this lesson exists to make that line true.

Step 4: write eval.py and watch one case fail

Save this as eval.py. Three cases. The first is the happy path. The second checks a different runbook page. The third is the trap: the keywords match, but p95 is under the threshold, so the right answer is no action at all.

"""Eval set for the triage assistant. Three cases, no model, no network.

Case 1 is the happy path. Case 2 checks a different runbook page.
Case 3 is the trap: the keywords match, but p95 is under the threshold,
so the right answer is no action at all.
"""
import triage

CASES = [
    {"name": "latency spike after deploy",
     "alert": "2026-11-21T09:14:02Z checkout p95 latency 3100 ms, threshold 800 ms\n"
              "2026-11-21T09:14:05Z deploy checkout v2.14.3 finished 09:12:44Z",
     "expect": ["RB-01", "RB-03"]},
    {"name": "error rate with no deploy",
     "alert": "2026-11-21T10:02:11Z checkout error rate 4.1%, threshold 1.0%",
     "expect": ["RB-02"]},
    {"name": "latency under threshold",
     "alert": "2026-11-21T11:20:00Z checkout p95 latency 400 ms, threshold 800 ms",
     "expect": []},
]


def main():
    entries = triage.load_runbook()
    passed = 0
    for c in CASES:
        got = [e["id"] for e in triage.analyze(c["alert"], entries)["matched"]]
        ok = got == c["expect"]
        passed += ok
        print(("PASS" if ok else "FAIL"), "-", c["name"],
              "| expected", c["expect"], "| got", got)
    print("%d/%d eval cases passed" % (passed, len(CASES)))


if __name__ == "__main__":
    main()
python3 eval.py

Expected output, exactly as it ran in this build:

PASS - latency spike after deploy | expected ['RB-01', 'RB-03'] | got ['RB-01', 'RB-03']
PASS - error rate with no deploy | expected ['RB-02'] | got ['RB-02']
FAIL - latency under threshold | expected [] | got ['RB-01']
2/3 eval cases passed

The failure is honest, and it is the most useful line in this lab. The tool matched the keywords and recommended a rollback for an alert that was under the threshold. A keyword match cannot tell a real incident from a sentence that happens to share the words. The eval set caught it before any reviewer did. That is what evals are for.

Step 5: add the threshold guard and re-run

Three lines in analyze(), before the keyword match:

    below = p95 is not None and threshold is not None and p95 < threshold
    matched = [] if below else [
        e for e in entries if all(k in low for k in e["keywords"])
    ]

And four lines in report(), right after the FACT line:

    if r["below"]:
        lines.append("BELOW THRESHOLD: p95 is under the threshold. "
                     "No action. Log it and move on.")
        return lines

Add "below": below, to the dict that analyze() returns. Then run the evals again.

python3 eval.py

Expected output, exactly as it ran in this build:

PASS - latency spike after deploy | expected ['RB-01', 'RB-03'] | got ['RB-01', 'RB-03']
PASS - error rate with no deploy | expected ['RB-02'] | got ['RB-02']
PASS - latency under threshold | expected [] | got []
3/3 eval cases passed

Two of the three cases did not change. The third went from a wrong rollback to no action. That is the whole fix. It is also the story you tell in the interview. The evals found a real bug, and the guard is the answer to the question what would you change.

Step 6: write the README and the 60-second answer

Save this as README.md. Four sections, no more. The eval result is on the page, with the number.

# Triage assistant

## What it does

It reads one alert, finds the runbook pages that fit, and answers with
sources. It runs on this machine. No model call, no API key, no network.
The match is keyword plus one threshold guard. The answer cites the
runbook pages it used, by id.

## How to run it

```
python3 triage.py
python3 eval.py
```

`triage.py` reads `alert.txt` and prints the answer. `eval.py` runs the
3-case eval set and prints PASS or FAIL per case.

## Evals

3 cases, run with `python3 eval.py`. Result: 3/3 passed.

- Latency spike after deploy: expects RB-01 and RB-03.
- Error rate with no deploy: expects RB-02.
- Latency under threshold: expects no action.

## One trade-off

Keyword match is fast and easy to explain, and it is dumb. It cannot tell
a real incident from a sentence that happens to share the words. The
threshold guard catches the cheapest version of that mistake. The next
step is a real retriever with scores, not more keywords.

Save this as answer.md. Read it out loud. It should take about sixty seconds.

What it does: the triage assistant reads one alert and answers with runbook sources.
One number: the eval set passes 3 of 3 cases, and the demo runs in one command.
One trade-off: keyword match is fast and easy to explain, and it is dumb. It cannot tell a real incident from a sentence that shares the words. The threshold guard catches the cheapest version of that mistake.
What is next: a real retriever with scores, not more keywords.

Check yourself

Three outcomes, all checkable in your terminal. python3 triage.py prints SOURCES: RB-01, RB-03. python3 eval.py prints 3/3 eval cases passed. The README check in Go deeper prints 4/4 sections present. If any of the three is missing, the portfolio is not ready to send.

Check yourself

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

Basic to master

A portfolio is not one thing. It is four levels of the same job, and every hiring loop I have seen sits on one of them. The levels are not about how many projects you have. They are about how much of your work a stranger can check without trusting you. Read them in order. Each level fixes the failure that hurt the most at the level below it.

Basic: One project, runs on your machine, README tells how

At the basic level, you have one project that runs with one command, and a README that says what it does. No evals. No write-up. The demo is the whole portfolio. It works when the reviewer runs it herself, and it breaks the moment she asks how you know it works.

Uses: A first portfolio piece. A project you show in a screening call, where you are in the room to run it.

Failure modes: The demo only runs on your laptop. The README command does not work. The reviewer asks one question and there is no answer behind the demo.

Do this: Pick one on-call pain you have felt. Write the README first, then the code. If you cannot write the README, the project is too big. Cut it in half.

Try it: Basic

My demo runs and the reviewer asks how I know it works. What is missing?

Now do it: Pick one on-call pain you have felt. Write the README first, then the code. If you cannot write the README, the project is too big. Cut it in half.

Intermediate: Eval set, pass rate on the README

At the intermediate level, the project has an eval set. Ten cases or more, each with an expected answer, and the pass rate is on the README. The reviewer runs the evals herself. She does not have to trust your demo. She can read the failures.

Uses: A project you send with an application. The evals do the talking while you wait for a reply.

Failure modes: The eval set measures the easy cases only. The pass rate is 100 percent, and the reviewer trusts it less, not more. A perfect score with no hard cases is a claim, not proof.

Do this: Write ten eval cases before you add the next feature. Include one case the tool gets wrong, and write down why. That case is the most honest line in the repo.

Try it: Intermediate

My eval set passes 100 percent. Why should I trust it less, not more?

Now do it: Write ten eval cases before you add the next feature. Include one case the tool gets wrong, and write down why. That case is the most honest line in the repo.

Advanced: This lesson: grounded answers, live demo, interview answers

At the advanced level, the project answers with sources, the demo runs from one command on a clean machine, and you have interview answers ready. The 60-second answer. The trade-off answer. The failure answer. This is the lesson you just walked. The tool is small. The proof around it is complete.

Uses: The project from this lesson. A portfolio piece you can defend in a live interview, under a clock.

Failure modes: The trade-off answer is thin. The interviewer asks what you would change, and the answer stops. The proof is strong and the thinking sounds borrowed.

Do this: Build the triage tool from the lab. Add the threshold guard. Record yourself answering the five mock questions in the design exercise, one minute each. Listen to the recording. Cut every sentence that has no number in it.

Try it: Advanced

The interviewer asks what I would change about my tool. What answer falls flat?

Now do it: Build the triage tool from the lab. Add the threshold guard. Record yourself answering the five mock questions in the design exercise, one minute each. Listen to the recording. Cut every sentence that has no number in it.

Master: The project as a system, and the second one reuses the harness

At the master level, the project owns budgets in time and in evidence, and the budgets are in version control. The eval set grows with every bug. The README names the cost of a run. The second project reuses the same harness: same eval runner, same README shape, same grounding check. At 10x the traffic, the retrieval hop gets a real index. At 100x, the eval set runs in CI on every push, and a failing eval blocks the merge.

Uses: A portfolio of two or three projects that share one harness, with evals in CI and a cost line on every README.

Failure modes: The eval set grows and nobody prunes it. The harness becomes the project, and the project becomes a demo of the harness. The second project copies the first one's trade-offs without thinking.

Do this: Put the eval set in CI so a failing case blocks the merge. Then start the second project with the same harness, and write down the one trade-off that changes between the two.

Try it: Master

My eval set grows and nobody prunes it. What does the project become?

Now do it: Put the eval set in CI so a failing case blocks the merge. Then start the second project with the same harness, and write down the one trade-off that changes between the two.

Go deeper

Pick a project you have felt

The most common portfolio mistake is picking a project from a list of ideas. A list gives you a project you do not care about, and the interviewer can tell in one question. Pick a pain you have felt on call instead. A page that woke you up. A runbook you could not find. A dashboard you read wrong at 2 AM. The pain is the reason the project exists, and it is the first sentence of the interview answer. If you have never felt the pain, pick a smaller project. A log search tool. A deploy checklist. A small thing that works is worth more than a big thing that does not.

The README is a contract

Four sections. What it does, in two sentences. How to run it, in one command. Evals, with the pass rate as a number. One trade-off, named plainly. Each section is a promise, and the reviewer can check every one of them in five minutes. What it does is checked by running the demo. How to run it is checked by typing the command. Evals are checked by running the evals. The trade-off is checked by asking about it. A README with ten sections promises ten things and proves none of them. A README with four sections promises four things and proves all four.

Evals are the proof, not the demo

A demo is one run, on one input, watched by one person. An eval set is many runs, on many inputs, with the expected answers written down before the run. The difference is the direction of the claim. A demo says it worked. An eval set says here is what working means, and here is the score. The lab in this lesson has three cases. That is a small set, and it still caught a real bug. The threshold guard exists because case three failed. Write the cases before you write the fix. A case written after the fix is a test of the fix, not of the tool. And keep one failing case on purpose. A set that never fails is a set that never measures anything hard.

The 60-second answer has a shape

Four sentences. What it does. One number. One trade-off. What is next. The number is the eval result, or the time, or the cost. The trade-off is the decision you would defend. The next step is the thing you would build with one more week. Practice it out loud, with a timer. Sixty seconds is short, and the first time you try it you will take three minutes. Cut sentences until it fits. Cut adjectives first. Keep the number. An interviewer remembers one number from an answer. Give her the right one.

Save this as answer.md. It is the same template from the lab, and it is the shape every interview answer in this lesson follows.

What it does: the triage assistant reads one alert and answers with runbook sources.
One number: the eval set passes 3 of 3 cases, and the demo runs in one command.
One trade-off: keyword match is fast and easy to explain, and it is dumb. It cannot tell a real incident from a sentence that shares the words. The threshold guard catches the cheapest version of that mistake.
What is next: a real retriever with scores, not more keywords.

Price it yourself: the README check

Write the script below as readme_check.py and run it with python3 readme_check.py README.md. It checks the four sections from the contract above. No model is called. This is a string check, and it runs on this machine with plain Python.

"""README checker for the portfolio project. Four sections, no exceptions.

A portfolio README is a contract. It tells a stranger what the project
does, how to run it, what the evals say, and the one trade-off you made.
Run: python3 readme_check.py README.md
"""
import sys

REQUIRED = ["What it does", "How to run it", "Evals", "One trade-off"]


def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "README.md"
    with open(path) as f:
        text = f.read()
    found = 0
    for section in REQUIRED:
        ok = section.lower() in text.lower()
        found += ok
        print(("FOUND  " if ok else "MISSING"), "-", section)
    print("%d/4 sections present" % found)
    if found < 4:
        print("Add the missing sections before you send this link to anyone.")


if __name__ == "__main__":
    main()

Expected output, exactly as it ran in this build:

FOUND   - What it does
FOUND   - How to run it
FOUND   - Evals
FOUND   - One trade-off
4/4 sections present

Run it again with one section deleted from the README. The script prints MISSING for that section and 3/4 at the bottom. That is the check doing its job. A contract with a missing clause is not a contract.

Do it yourself: run it from a clean copy

Copy the project folder to a new directory, the way a reviewer would clone it. Then run the three commands from the README. No edits, no fixes, no files from your laptop.

cp -r triage-project /tmp/portfolio-clean
cd /tmp/portfolio-clean
python3 triage.py
python3 eval.py
python3 readme_check.py README.md

Expected output, exactly as it ran in this build:

ALERT: 2026-11-21T09:14:02Z checkout p95 latency 3100 ms, threshold 800 ms
FACT: p95 is 3100 ms, threshold is 800 ms
MATCHED: RB-01 - Checkout latency is high
MATCHED: RB-03 - A deploy just finished
ANSWER: Check the checkout queue depth first. If p95 stays above 800 ms for 5 minutes, roll back the last deploy. Compare the deploy diff with the previous version before any rollback.
SOURCES: RB-01, RB-03
PASS - latency spike after deploy | expected ['RB-01', 'RB-03'] | got ['RB-01', 'RB-03']
PASS - error rate with no deploy | expected ['RB-02'] | got ['RB-02']
PASS - latency under threshold | expected [] | got []
3/3 eval cases passed
FOUND   - What it does
FOUND   - How to run it
FOUND   - Evals
FOUND   - One trade-off
4/4 sections present

If any of the three commands fails in the clean copy, the portfolio is not ready. Fix the repo, not the clean copy. The clean copy is the reviewer. The reviewer does not fix your repo for you.

One time it broke

This one stayed with me because the demo worked in rehearsal and died in the room. Twenty rehearsals, and not one of them ran from a clean copy.

What broke

It was a Tuesday morning. A video interview, second round. The interviewer asked me to share my screen and run the project. I typed the command I had typed twenty times. python3 triage.py. The terminal said FileNotFoundError: runbook.json. The file was on my laptop, in a folder above the repo, and I had never committed it. The tool had read it from that path for a month. The demo I had rehearsed twenty times had never run from the repo alone.

Timeline

  • 09:58I open the repo, share my screen, and type the command.
  • 10:00FileNotFoundError. runbook.json is not in the repo. I say I will fix the path. I type the absolute path from my laptop. It works, on my laptop, and the interviewer has learned nothing.
  • 10:04The interviewer asks me to clone the repo fresh and run it. I clone it. Same error. The demo is dead in front of two people.
  • 10:10I paste the runbook into the chat as text and talk through the answer by hand. The interview ends on time. The demo never ran.
  • Next dayI add one rule to my own checklist. Every portfolio project gets run once from a clean clone, on a machine that is not mine, before the link goes out.

What changed after

Three things. First, the repo holds everything the tool needs. No file lives outside it. No absolute path anywhere. Second, the README command is the command I run in CI, not the one I run on my laptop. Third, I rehearse the failure, not just the demo. I delete the runbook, run the tool, and read the error out loud. A demo that has never failed in rehearsal fails in the room. A demo that has failed in rehearsal gets fixed in the room.

If you remember nothing else

Design exercise

Build the portfolio page for the triage tool. One README, one eval set, one 60-second answer, and a five-question mock interview script. The README must pass readme_check.py 4 of 4. The eval set must have five cases, not three, and one of the five must fail on purpose, with the reason written down. The mock script must have five questions: why this project, how do you know it works, what would you change, what broke, and what did the evals teach you. Record yourself answering all five, one minute each. The checkable outcome is the recording and the rubric below.

Clarifying questions to ask

  • Who reads the README: a recruiter who skims, or an engineer who runs the evals, and which one decides?
  • What counts as a case in the eval set: one alert, or one alert plus the expected runbook pages?
  • What is the one trade-off the 60-second answer names, and does the README name the same one?
  • How long can the demo be: one command, or one command plus setup, and who installs the setup?
  • What happens when the interviewer runs the evals and one fails: do you defend the failure, or fix it live?

Rough sizing, worked

Start with the README. Four sections, twenty lines. Then the eval set. Five cases, three from the lab plus two new ones: an alert with no deploy, and an alert with a metric the runbook does not cover. The failing case is the second new one. The tool says NO MATCH and the eval expects a match. That failure is honest. It says the runbook is thin. Write that down in the README under the trade-off. Then the mock script. Five questions, five one-minute answers. Score each answer 0 to 2. One point for a claim with a number. One point for the evidence behind it. Ten points is a perfect round. Eight is a strong round. Below six, rewrite the answers, not the project.

Trade-offs to name

Five eval cases buy proof and cost maintenance, so I keep five and I prune one every time I add one. A failing case on purpose buys honesty and costs a question in the interview, so I write the reason next to the failure and I answer the question before it is asked. One minute per answer buys focus and costs depth, so I give the number first and the story second. A clean clone rehearsal buys a working demo and costs ten minutes, so I do it the night before, not the morning of.

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

End of the course
That is all 249 lessons. You made it to the end.

You started with a computer you could point at and finished with the work around the engineering: delivering for a client and showing what you built. Every stage is still there. Revisit the one you need, or start again from the first lesson.

Back to Lesson F01 →

Or browse the full course from the Lessons index.