knaxuslearn · build · ship

Roadmaps / Go / Phase 4

Phase 4 of 4 · Study weeks 13-16

Quality, supply chain and shipping

This phase makes the last checkpoint possible: a service you can build the same way every time, defend and upgrade.

Topics every week

  1. Week 138 h
    • go vet, golangci-lint and custom rules
    • Code layout for a service
    • Package boundaries and internal

    Hand inA lint config where a seeded violation fails CI

  2. Week 148 h
    • Modules and go.sum
    • govulncheck
    • Dependency review
    • Reproducible builds

    Hand inA vulnerable dependency caught in CI and replaced

  3. Week 158 h
    • goreleaser
    • Signing with cosign
    • SBOMs
    • Container images and minimal bases

    Hand inA signed release with an SBOM and a verification step

  4. Week 168 h
    • Go versions and the upgrade policy
    • The runbook
    • Postmortem writing
    • Review of the whole service

    Hand inCheckpoint 4, the runbook and the upgrade memo

Practice projects

  • Practice 1, the lint rule (Week 13): ban a package from importing another. Done when: a seeded import fails CI and passes after the fix.
  • Practice 2, the vulnerable dependency (Week 14): add an old version of a library with a known flaw. Done when: govulncheck fails the pipeline, names the function reached and the fix, and the fix passes.
  • Practice 3, the signed release (Week 15): build a release twice. Done when: both builds match byte for byte, the artifact is signed, and verification rejects a changed copy.
  • Optional, a Go upgrade rehearsal: move to the next Go release in a branch. Done when: a table compares tests, p99, RSS and build time, and says whether to move.

GitHub repos to study

Existence and last commit were checked on 22 Nov 2026 by shallow clone. Every repository below had a commit in the last 12 months.

RepoWhat to readWeek
golangci/golangci-lintHow linters are configured and run together13
golang/vulnThe vulnerability database and how govulncheck reads it14
goreleaser/goreleaserA release pipeline: builds, archives and checksums15
sigstore/cosignSigning and verifying artifacts15

Milestone checkpoint

Run Checkpoint 4. Build twice and compare, add the lint rule, the vulnerability check and the signing step, then write the runbook and the upgrade memo. Hand in the CI output (a failing and a passing run), the signed release and its verification, ADR-6 (dependency policy) and ADR-7 (which Go release you run and when you move).

Check yourself

Answer each question in your head first, then open it to check.

  1. What does govulncheck tell you that a version list does not?
    Whether your code actually calls the vulnerable function, so you can rank what to fix first.
  2. Why does go.sum matter for supply-chain safety?
    It records the hash of each module version, so a changed module is detected.
  3. What does signing an artifact prove?
    That the artifact came from the holder of the signing identity and has not changed since. It does not prove the code is free of bugs.
  4. Why keep the two most recent Go releases in CI?
    Go supports the two latest releases, and testing both shows a problem before you are forced to move.
  5. What belongs in a runbook for a hanging endpoint?
    How to see it (the dashboard and the query), what the service does by itself (the limit and the shed), when to page, and how to park and replay events.