Year 5 Final Exam = ROOT Final Exam

The final test. Full day. Three parts: live-system review, capstone defense, career story. The entire 5-year scope is in scope. Pass = graduation.

This is the only exam in ROOT that has no scope limit. Year 1’s exam tested seven phases. Year 2’s tested six. Year 3’s tested six. Year 4’s tested six. The Year 5 exam tests all thirty — every phase, every project, every pattern, every weekly log, every postmortem. Plus the artifacts that only exist at graduation: Abukix Studio live at studio.abukix.dev, mlship v2 with real users, the pattern paper externally reviewed and published, and the agent layer (services/aiops/) operating the platform you spent 60 months building.

What’s measured isn’t a checklist. The bar is whether a stranger landing on Abukix Studio could conclude — without ever meeting you — that you reason in patterns and ship real systems. The exam audits that conclusion three ways: a reviewer pokes at the live platform (is it production-shaped?), a panel defends the capstone (is the synthesis Staff/Principal-grade?), and you tell the career story in your own words (does the depth match the title?). Two of the three are external; one is yours. All three must hold.

Treat this exam with the weight it deserves. It’s the only audit in ROOT that determines a title. It’s also the only audit where the pass criteria can’t be reduced to “did the test pass” — passing requires that the platform, the artifacts, and the engineer behind them all hold up under scrutiny at the same time. That’s not theatre. That’s the bar Staff/Principal AI Platform Engineers are paid to clear every quarter for the rest of their careers; this exam just makes the audit explicit, once.

---

When to take

After Phase 30 validation criteria all green: mlship v2 launched, paper published, all patterns DEEP. Schedule ~3 weeks ahead — Year 5’s exam needs the longest runway because the panel coordination, hosted demo stability, and reviewer scheduling don’t compress.

What not to bring to the exam

Do not bring: a “graduation deck” full of generalities, a CV-shaped narrative dressed up as a career story, a defense of the pattern paper that hasn’t been pressure-tested by external readers, a Studio demo that hasn’t been verified end-to-end the morning of. Do bring: 60 months of weekly logs, the actual postmortems behind the patterns you’ll cite, the git log of mlship (the trade-offs are in the commit history), and a willingness to accept critique without flinching. The capstone defense rewards specific and punishes abstract.

---

Setup

• Abukix Studio live at studio.abukix.dev
• mlship v2 public + at least 5 real users
• Pattern paper published (blog at minimum; conference submission preferred)
• platform-ctl + basecamp + terralabs all public
• All 9 basecamp tiers operational
• All 5 composition recipes runnable end-to-end
• A panel of 2+ external reviewers (peers, mentors, or the root-exam skill in panel mode)
• Full day uninterrupted

How to prepare in the three weeks before

The right preparation is not polishing slides. It’s stress-testing the artifacts. Run the hosted demo from a fresh browser on a fresh network — does it work? Trigger a synthetic alert and watch services/aiops/ actually triage it — does it produce a useful hypothesis or a vague summary? Hand the pattern paper to a peer who hasn’t read it before and ask for the strongest counterargument — does your defense of the thesis hold? Reach out to the 5+ mlship users for a 15-minute call each — what would they tell the panel? The exam is the audit; the three weeks before is your last chance to make sure the audit reflects reality rather than ambition.

---

Format

3 parts, full day:
  Part 1: Live system review        (180 min)
  Part 2: Capstone defense          (120 min)
  Part 3: Career story              (60 min)

---

Part 1: Live system review (180 min)

External reviewer (or AI examiner panel) reviews your live Abukix Studio. The reviewer’s job: verify the platform is real, not a portfolio piece.

Required demonstrations:

[ ] Live cluster tour — basecamp managing K3s + EKS + GKE
[ ] All 9 tiers operational (Foundation through Agents)
[ ] Reviewer triggers a synthetic alert; AIOps triages it; produces a hypothesis
[ ] Reviewer asks a question to command palette agent (notes-rag); gets useful answer
[ ] Reviewer runs a composition recipe via Studio: train→deploy or RAG-over-logs
[ ] Reviewer requests a deploy via mlship from a sample model file
[ ] Reviewer reviews a recent postmortem in ops-handbook
[ ] Reviewer runs platform-ctl service status on a basecamp service

Pass criteria:

• Platform reviewer says “yes, this is production-shaped”
• AIOps response is genuinely useful (not just “looks helpful”)
• All composition recipes work
• No critical security findings (no plaintext secrets, no public LLM endpoints, no missing auth)
• The reviewer can navigate the platform without you sitting next to them

What passing looks like: the reviewer’s notes read like notes from a real production review — small specific issues, a couple of “I’d do X differently,” and a clear overall verdict that this is a platform, not a demo. The agents in services/aiops/ either help, hinder, or stay out of the way; all three are graded outcomes, but “stay out of the way appropriately” beats “barge in unhelpfully.”

---

Part 2: Capstone defense (120 min)

Present mlship v2 + the pattern paper to the panel.

mlship defense (60 min)

Questions you must answer convincingly:

• Why does mlship exist? Who’s it for?
• What did you cut from scope at launch (and why)?
• Walk through the auto-detection engine
• What’s your retention story for the 5 real users?
• How does mlship integrate with basecamp + Abukix Studio?
• What would you do differently if starting over?
• Where does mlship lose to BentoML / Cog / Truss? Where does it win?

Pattern paper defense (60 min)

Questions you must answer convincingly:

• What’s the thesis in 1 sentence?
• Why this pattern? Why this venue?
• What 3 things did you change in revision based on reviewer feedback?
• What’s the strongest counterargument to your thesis?
• How does the paper relate to your homelab work specifically?
• What did writing this teach you that operating didn’t?

Pass criteria:

• Defense is convincing + specific (not abstract)
• You accept critique gracefully + adjust where warranted
• You can articulate trade-offs you made deliberately
• Citations of pattern library entries are precise (you wrote them; you should know them cold)

What passing looks like: every answer has a number, a commit, a postmortem, or a pattern entry behind it. “I cut X because Y, and you can see the ADR in ops-handbook — here’s the link.” When the panel pushes on the strongest counterargument, you don’t fold and you don’t dig in; you say “that’s the trade-off I made and here’s the evidence I weighed.” That’s Staff/Principal posture.

---

Part 3: Career story (60 min)

Articulate (written or spoken): “I started ROOT 5 years ago in an SRE Support role. I’m graduating today as Staff/Principal AI Platform Engineer. What’s true now that wasn’t true then?”

Use specific examples. The story is the audit.

You should reference at minimum:

• One incident where pattern-recognition (not Stack Overflow) was the root-cause path
• One contribution you made upstream that mattered
• One time you decided NOT to use a tool because the pattern was already familiar
• One time the homelab platform served you (not just demos) — notes-rag query, AIOps triage, personal-api dashboard
• One thing you’d tell past-you on Day 1 of ROOT

Pass criteria:

• Story is honest, specific, demonstrates depth + breadth
• Self-reflection is clear-eyed (not all wins; not all losses)
• Forward-looking statement about the post-ROOT chapter
• The story could be handed to a Day-1 ROOT student as evidence the program actually works

What passing looks like: the story is short. Specific examples beat generalities every time. “I learned a lot about distributed systems” fails; “in Month 18, the EKS upgrade broke the load balancer controller, and recognizing it as a reconciliation mismatch — not an AWS bug — was the moment Y2 actually clicked” passes. The audit is in the specificity.

---

Overall pass criteria

[ ] Part 1: platform reviewer's verdict is "production-shaped"
[ ] Part 2: capstone defense convincing for both mlship + paper
[ ] Part 3: career story honest + specific + forward-looking
[ ] All Year 5 validation criteria satisfied (incl. patterns DEEP)
[ ] mlship v2 has 5+ real users
[ ] Pattern paper has 2+ external readers + is published

A failed graduation exam is rare but not impossible. If you fail: retake in 4-8 weeks. The intervening weeks are spent on the specific gap the panel named — not on cramming, not on more reading. If the live system review failed, fix the platform. If the capstone defense failed, get more external reviewers and harden the thesis. If the career story failed, write more weekly-log retrospectives and find the specifics.

---

After passing: ROOT graduation

60 months. 30 phases. 5 yearly exit ramps.
~50 patterns deepened through deliberate practice.
One complete data/AI platform — kernel to LLM.
Capstone OSS shipped + pattern paper published.
~10 OSS projects with stars + users.

Multi-disciplinary depth (Linux, networking, databases,
distributed systems, cloud, platform engineering, observability,
data engineering, ML, agents, security).

You can:
- Debug any layer of the stack from kernel to LLM
- Reason in patterns; tools are interchangeable implementations
- Architect + ship platform products that other engineers use
- Operate AI/ML systems at production rigor
- Write Staff/Principal-grade synthesis that defends scrutiny
- Mentor others starting their own version of this journey

You are: Staff/Principal AI Platform Engineer
         (or chosen elective endpoint)

The depth is yours forever. The next chapter is whichever one you pick.

---

Update on the day of graduation

[ ] program/overview.md Status block:
    - Started: YYYY-MM-DD
    - Graduated: YYYY-MM-DD
    - Capstone: mlship v2 launched + pattern paper published
[ ] program/story.md: write the graduation chapter
[ ] README.md status: "ROOT graduated YYYY-MM-DD. 60 months. ~50 patterns DEEP."
[ ] LinkedIn: graduation post
[ ] Blog: "ROOT graduation — 5 years in"
[ ] Update career story doc with the post-ROOT decision

---

What’s next

You’re 30-31. The depth lasts 30 years. The exit-ramp options:

1. Stay on a Staff/Principal track at scale — the artifacts + writing + OSS make you stand out
2. Found an AI startup — mlship is potentially a product; the platform skill is the moat
3. Applied AI lab — frontier-model labs hire engineers with this depth profile directly
4. OSS maintainership — your contributions across terralabs, basecamp, mlship, and upstream PRs opened the door
5. Whatever future-you wants — you’ve earned the freedom to decide with data, not speculation

Whichever you pick — the depth is yours forever.

→ Start the post-ROOT chapter.

---

Anti-patterns

Anti-pattern	Why
Cramming mlship features in the final week	Quality over breadth was the contract
Defending the paper poorly because reviewer feedback hurt	Critique is data; defending stubbornly is anti-Staff
Career story full of generic “I learned a lot” platitudes	Specificity is the audit; “I learned” without example fails
Skipping the public launch components for graduation paperwork	The launches ARE the graduation — they’re the artifacts
Failing this exam silently	If you fail, retake in 4-8 weeks. Don’t pretend to have graduated.
Treating the panel as adversaries	They’re calibrating against the bar; you are too. Same team.