A course grounded in your services
The Go Programming Language, from newcomer to interview-ready
Every concept anchored to real code in conversationmgmt, notification & spike.
You write Go in this monorepo every day, but you came to it from another language — so the idioms, the value semantics, concurrency, and generics aren't reflexes yet. This course builds the mental model an interview tests, from the ground up, pinning each idea to code you already own. It's broad, so it's long: six parts, built one lesson at a time, with a new senior-backend finish line. Lessons are short — one win each. Read them in order.
The whole course at a glance
Six parts, 31 lessons, each pinned to a real backend or interview skill.
Part 1 — Foundations: Go's value model available now
The thing newcomers get wrong most: what Go copies, and what it shares.
1 · The Go mental model
Why Go looks the way it does — simplicity, compilation, values over magic.
ready2 · Types & zero values
Declarations, the static type system, and why the zero value is a feature.
ready3 · Structs: value vs pointer
What's copied vs shared — the single most important Go semantics to master.
ready4 · Slices & maps
The reference-like headers, and the aliasing/nil gotchas interviews love.
readyPart 2 — Methods, interfaces & generics available now
Go's design core — how types plug together. Do them in order.
5 · Methods & receivers
The method-set rule — why *Email, not Email, satisfies our interfaces.
6 · Interfaces
Implicit satisfaction, small consumer-side interfaces — our repo's mockable pattern.
ready7 · The nil-interface gotcha
Why a non-nil interface can hold a nil pointer — the #1 Go interview trap.
ready8 · Composition & embedding
Go's answer to inheritance, all over your Kafka engine and claims types.
ready9 · Generics
Type parameters + the "generics or interface?" decision, via KafkaServicer[T].
Part 3 — Errors & idiomatic Go available now
Errors as values, and the everyday idioms — including a real bug in our own handlers.
10 · Errors are values
%w wrapping, sentinels — and the %v bug in create_email_handler.
11 · errors.Is / errors.As
Comparing & extracting through the wrap chain — how errorx.ToStatusError works.
12 · gRPC status codes
Mapping domain errors to codes.* at the controller boundary, our way.
13 · Idioms
defer, functional options, named returns, zero-value design.
Part 4 — Concurrency & context available now
The biggest interview pillar — and where your Kafka engine finally reads like an open book.
14 · Goroutines
"Concurrency is not parallelism"; the go statement; goroutine leaks.
15 · Channels & select
Buffered vs unbuffered, share-by-communicating, and the ctx.Done() case.
16 · sync primitives
Mutex, WaitGroup, Once — and "channels or a mutex?"
ready17 · context.Context
Cancellation, deadlines, request-scoped values — and our Background() subtlety.
18 · Concurrency patterns
Worker loops, errgroup, graceful shutdown, fan-in, panic recovery.
19 · Data races & the memory model
Happens-before, the -race detector, why our mutex is required.
Part 5 — Testing, tooling & performance available now
The last part — how you prove code works and make it fast, plus the runtime under it all.
20 · Table-driven tests
The Go testing idiom + testify, in our repo's exact t.Parallel/subtest style.
21 · Mocks & interfaces in tests
Testing with no database — how MockEmailRepo and mock_database wire in.
22 · Benchmarks & pprof
Measure, don't guess — b.Loop, -benchmem, profiles, escape analysis.
23 · The runtime
The GMP scheduler and the concurrent GC — why goroutines are cheap.
readyPart 6 — Senior Go backend engineering new
The senior stretch — runtime trade-offs, bounded concurrency, memory behaviour, architecture, and interview-grade answers.
24 · Escape analysis: stack vs heap
Why values escape, how allocations become GC work, and how to reason about the cost.
new25 · GC tuning: GOGC & GOMEMLIMIT
What the garbage collector optimises for, and how senior engineers talk about latency vs memory.
new26 · errgroup & bounded concurrency
Fail-fast fan-out, cancellation propagation, and putting limits on concurrent work.
new27 · sync.Pool & memory layout
When reuse helps, when it hurts, and why struct shape affects memory and cache behaviour.
new28 · Architecture in this repo
Small interfaces, ports/adapters, constructors, and why these boundaries matter in backend Go.
new29 · Backpressure, timeouts & retries
How senior Go services stay alive under load instead of leaking work and compounding failures.
new30 · Senior Go interview questions
High-signal prompts with the best answer shape for backend and runtime questions.
new31 · Mock senior Go interview pack
A retrieval-first mock round with scoring, recovery mapping, and follow-up review prompts.
newReference shelf
Course mind map ↗
The whole roadmap on one canvas — foundations, concurrency, testing, and the new senior-backend extension.
Cheat sheet
Dense revision sheet + interview one-liners.
Glossary
The canonical vocabulary, opinionated.
Repo Go map
Ground truth: our idioms, patterns, file:line.
Resources
go.dev, GOPL, 100 Go Mistakes, Learn Go with Tests, GC guide, memory model, pipelines.
Senior backend playbook
The compressed version of the new senior-only part: runtime, memory, bounded concurrency, and architecture.