Day 90 — Retrospective & roadmap

Updated

July 30, 2026

Day 90 — Retrospective & roadmap

Stage VIII · ~3h
Goal: Close the Go volume deliberately—self-demo against a stage checklist, write RETRO.md, and draft a next-30-days learning roadmap (including Go 1.27+ awareness).

Note

This is a completion ritual, not a new feature day. Freeze the product; reflect and plan.

Why this day exists

Without reflection, 90 days becomes a blur of commands. A retrospective:

  • Certifies what you can demonstrate
  • Names remaining gaps without shame
  • Points effort after this volume (NixOS volume, job prep, deeper systems)

Done is a demo, a retro, and a next step—not a perfect program.

Theory 1 — Self-demo protocol

Block 60–90 minutes. Treat yourself as an external reviewer.

Demo sequence

  1. Open CAPSTONE.md pitch (30 seconds).
  2. Run ./demo.sh (or README path) cold.
  3. Show one test command green.
  4. Show one evidence file from Day 89.
  5. Optional: container run or file on release binary.
  6. Stop. Do not continue coding unless demo is broken.

Record in RETRO.md whether demo was pass / pass-with-notes / fail.

If the demo fails

Severity Action
Script flake Fix script only; re-run evidence if SHA changes
Real regression Fix minimal; re-run evidence.sh; note in RETRO
Scope never shipped Record FAIL honestly; roadmap item #1

Do not expand features to “save” the demo.

Theory 2 — Stage checklist map

Tick honestly:

Stages I–III — Language & concurrency

  • Toolchain / modules mental model
  • Types, slices, maps, structs
  • Interfaces & errors
  • Goroutines, channels, context, race detector

Stages IV–V — Generics, quality, stdlib I/O & HTTP

  • Generics judgment
  • Tables, fuzz, golden tests
  • io, JSON, net/http, slog

Stage VI — Data & APIs

  • database/sql + migrations
  • REST design + auth basics
  • Integration tests
  • TLS awareness

Stage VII — Ship quality

  • Cross-compile / tags
  • vet + staticcheck
  • pprof + benchmarks
  • GC awareness
  • Containers
  • Metrics + light traces
  • govulncheck

Stage VIII — Architecture & capstone

  • Package boundaries / hexagon lite
  • Config, shutdown, flags
  • Load + security pass
  • Capstone design + six build days + evidence

Gaps become roadmap fuel—not failure labels.

Theory 3 — RETRO.md template

# Go volume retrospective

Date:
Capstone option: A | B | C
Demo: PASS | PASS_WITH_NOTES | FAIL
Go version:
Git SHA:

## What shipped
- 

## What I'm proud of
1.
2.
3.

## What was harder than expected
1.
2.

## Top 5 personal gotchas (career memory)
1.
2.
3.
4.
5.

## Metrics of the journey (rough)
- Lab days completed:
- Capstone LOC (optional):
- Tools now comfortable: (pprof, vegeta, staticcheck, ...)

## Gaps to close next
| Gap | Why it matters | First action |
|-----|----------------|--------------|
| | | |

## Stage checklist
(paste ticks)

## Evidence pointer
- evidence/README.md SHA:

## Thanks / notes to future self

Writing tips

  • Pride items first (avoids harsh-only narrative).
  • Gotchas should be actionable (“always set ReadHeaderTimeout”), not vibes.
  • Gaps need a first action smaller than a week.

Theory 4 — Next 30 days roadmap

Pick a track (not all):

Track 1 — Production Go deepening

  • Read Go 1.26 release notes again; skim early 1.27 notes when available
  • Add integration tests with testcontainers or similar
  • Practice one incident-style debug (pprof on a bug you invent)

Track 2 — Systems / platform

  • Start or continue 90DaysOfX NixOS volume
  • Wire your capstone into a Nix flake devshell
  • Explore systemd + Go service unit

Track 3 — Job / portfolio

  • Public README + architecture diagram
  • 5-minute Loom-style demo script
  • Map capstone bullets to resume language

Track 4 — Language mastery

  • Work through 100 Go Mistakes items you have not hit
  • Contribute a small fix to a library you use
  • Read parts of the Go memory model / spec you skipped

Roadmap rule: ≤3 active goals for 30 days. Write them as weekly outcomes.

## 30-day roadmap
### Goal 1
Week 1:
Week 2:
### Goal 2
Week 1:
Week 2:
### Goal 3
Week 1:
Week 2:
### Deliberate non-goals
-

Example filled roadmap

### Goal 1 — Capstone on Postgres
Week 1: migrate SQLite store interface to Postgres in docker compose
Week 2: integration tests green in CI

### Goal 2 — NixOS volume days 1–10
Week 1: finish days 1–5 labs
Week 2: days 6–10 + flake for capstone

### Goal 3 — Public writeup
Week 1: architecture diagram + README polish
Week 2: short blog post from RETRO pride items

### Non-goals
- Rewrite in Rust
- Multi-region deploy

Theory 5 — Go version currency

Record:

go version

Note: this volume targeted Go 1.26. When 1.27 ships, schedule a half-day:

  1. Read release notes
  2. go fix / try toolchain upgrade on capstone
  3. Re-run scripts/evidence.sh

Link back to Day 37 habits (go126 quality day).

## Toolchain note
Volume target: Go 1.26
My binary: go1.26.x
Next upgrade review date:

Theory 6 — Closing the monorepo loop

You have walked an expert-shaped path from toolchain mental models through concurrency, HTTP, data, ship quality, architecture, and a capstone with evidence.

Suggested next in this monorepo: content/02-nixos/—or return to the standalone Go book for deeper topical libraries.

Optional git hygiene:

git tag go-volume-complete
# or note SHA in RETRO without tagging

Lab

Suggested workspace: capstone root + notes folder.

  1. Run the self-demo protocol; capture result.
  2. Write full RETRO.md.
  3. Complete stage checklist ticks.
  4. Write 30-day roadmap with ≤3 goals.
  5. Optional: tag git go-volume-complete or note SHA in RETRO.
  6. Spot-check go test ./... still green.
  7. Celebrate briefly—then stop coding.

Stretch

  • 10-bullet “teach Day 1 student” summary of the volume.
  • Compare capstone to Day 62 gate service—what improved?
  • Record a 3-minute voice note walking the demo (private).

Worked example — “teach Day 1 student” bullets (stretch)

Write ten lines future-you would tell week-one you:

  1. Modules, not GOPATH, define projects.
  2. Interfaces are satisfied implicitly—design small.
  3. context.Context is the cancellation bus.
  4. Table tests beat clever tests.
  5. ReadHeaderTimeout is not optional on HTTP servers.
  6. Metrics for aggregates; traces for single requests.
  7. Distroless + non-root is the default ship shape.
  8. Config loads once at the root; validate or exit 2.
  9. SIGTERM must drain; liveness ≠ readiness.
  10. Demo script + evidence pack beat slides.

Paste into RETRO.md under “notes to future self” if useful.

Compare to Stage VI gate (Day 62)

Question Answer in RETRO
What quality bar improved? e.g. container + metrics + shutdown
What is still weaker? e.g. integration tests sparse
Would Day 62 service pass Day 89 evidence? yes/no + why

This anchors growth in artifacts, not feelings.

Common gotchas

Gotcha Fix
Using day 90 to rebuild features Freeze; document as roadmap
Harsh self-grade only List pride items first
Infinite roadmap Cap at 3 goals
Skipping demo because “obvious” Run it once cold
Not recording Go version Future you needs it
RETRO as diary dump Use the template sections
Comparing to imaginary expert Compare to Day 1 you
Forgetting evidence SHA Copy from evidence/README.md
Roadmap goals without weekly cuts Force Week 1 / Week 2 lines

Checkpoint

  • Self-demo executed and recorded
  • RETRO.md written
  • Stage checklist completed honestly
  • 30-day roadmap with ≤3 goals
  • Capstone evidence still green (spot-check tests)
  • Volume closed—no silent “I’ll finish later”

Commit

git add .
git commit -m "day90: retrospective roadmap close volume"

After this volume

Ship carefully. Measure first. Keep interfaces small. Prefer boring packages.

Done is a demo, a retro, and a next step—not a perfect program.