Domain 1 — Backend / distributed systems (largest gap)
No persistence anywhere. Every store (API keys, abuse counters, rate-limit
buckets, ThreatIntel scores) is an in-memory map. No database/sql, no
connection pooling, no transactions, no migrations, no N+1/exhaustion failure
modes — the incidents that actually dominate backend on-call.
No gRPC/protobuf, despite HTTP/2 (its transport) being covered in depth in
Week 9, and despite gRPC being explicitly named in target-domain scope.
No message queues / event-driven architecture — no idempotency-key
patterns, no outbox pattern, no at-least-once delivery reasoning.
No real observability stack.expvar + hand-rolled ring-buffer tracing is
taught as if it replaces Prometheus/OpenTelemetry rather than as a stepping
stone toward them.
Testing culture arrives 81 days late. Weeks 1–11 build production-shaped
code with zero _test.go files; Week 8 dedicates a full day to -race
auditing with nothing to run -race against except func main().
ADR-003 (Week 16) explicitly chooses in-process sync.Map over Redis
"because signals are ephemeral" — a deliberate, acknowledged gap that means
the learner never touches a real distributed cache/coordination client.
Domain 2 — Infra / DevOps tooling
Kubernetes is consumer-only knowledge. Liveness/readiness/startup probes,
SIGTERM drain semantics, and rollout behavior are referenced constantly as
analogies — but there is no client-go, no controller-runtime, no CRDs,
no informers/workqueues, no operator pattern anywhere in 120 days, despite
this being one of three explicitly named target domains.
No CLI tooling (cobra/viper/pflag). Every tool is a bare main.go
reading JSON files and OS signals, never a kubectl/docker-style CLI.
No containerization — no Dockerfile, multi-stage builds, or distroless
images, even though "ships as one static binary" is a running theme that
begs for a container story.
No IaC/GitOps — CI is described in prose ("require -race in CI") but
never expressed as an actual pipeline file anywhere in the 17 weeks.
Domain 3 — High-performance / low-latency systems
Foundations exist (sync.Pool intro, pprof registration, atomics, ring
buffers) but profiling is named far more than it's exercised — pprof
is "served automatically" in checklists without a walked CPU/heap profile
session in most weeks that mention it.
No GC/memory tuning (GOGC, GOMEMLIMIT, debug.SetGCPercent), no
escape-analysis workflow (-gcflags=-m), no benchstat-driven optimization
loop — benchmarking stays at raw ns/op/allocs/op numbers.
No lock-free/cache-conscious data-structure design beyond basic CAS loops
in the token/leaky-bucket limiters — no false-sharing, cache-line padding,
or GOMAXPROCS/scheduler-internals discussion.
The WAF (Week 10) is a real anti-pattern for a low-latency system: 5+
sequential regexes per request, no compiled multi-pattern matcher
(Aho-Corasick), no before/after benchmark of WAF overhead despite a load-test
tool being built specifically to measure it.
Everything stays at the net/http/stdlib-socket abstraction level — no
SO_REUSEPORT, TCP_NODELAY, kernel buffer tuning, io_uring, or discussion
of the microsecond-to-nanosecond budgets that trading/gaming SMEs live in.
Week 16's own perf work measures the proxy at 100–500µs — a full order of
magnitude looser than that floor.
