Write software that's fast, simple & concurrent
A foundations-first path into Go — the language behind Docker, Kubernetes and half the cloud-native tooling you already use. Start with syntax, types and the toolchain, move through structs, interfaces and idiomatic error handling, then into what makes Go different from everything else you've learned: goroutines and channels, all the way to a deployed, production-shaped capstone service. All 16 weeks are live, start to finish.
Prerequisites & tooling
What you should already know
- Basic programming in any language — variables, loops, functions
- Comfortable opening a terminal and running a command
- No prior systems programming, C, or concurrency experience required
- A Windows, macOS or Linux machine with the Go toolchain installed
Stack you'll work with
The same toolchain and standard library that ships Docker, Kubernetes and most cloud infrastructure tooling.
The full 16-week roadmap
Sixteen modules, from syntax and the toolchain through structs, interfaces, goroutines and channels, testing and REST APIs, to databases and a deployed capstone service. All 16 weeks are live below.
Go Fundamentals: Syntax, Types & the Toolchain
Install Go, write your first program, and learn the type system everything else builds on.
- Installing Go & understanding
go runvs.go build - Variables, constants, basic types & zero values
- Packages & managing dependencies with
go mod
Control Flow, Functions & Error Handling
Go's deliberately small set of control-flow tools, and the idiom that replaces exceptions.
if/switch& the singleforloop that replaceswhile- Functions, multiple return values & named returns
- Idiomatic error handling &
defer/panic/recover
Structs, Methods & Interfaces
Go's answer to objects — without the inheritance.
- Defining structs & attaching methods with value vs. pointer receivers
- Interfaces & Go's implicit, structural typing
- Composition over inheritance with embedding
Slices, Arrays & Maps in Depth
The collection types you'll reach for constantly, and the gotchas that trip up newcomers.
- Arrays vs. slices & how a slice's length, capacity & backing array relate
append, slicing pitfalls & when a slice silently shares memory- Maps: iteration order, the comma-ok idiom & zero values
Pointers & Memory Basics
Enough of the memory model to reason about what a function can and can't mutate.
- Pointers, the
&/*operators & when Go passes by value vs. by reference - Stack vs. heap & a practical mental model of escape analysis
- Garbage collection: what Go handles for you, and what it doesn't
Goroutines & Channels: Concurrency Fundamentals
The feature that sets Go apart — cheap, built-in concurrency.
- Launching goroutines & why they're cheaper than OS threads
- Channels for communicating between goroutines safely
- Buffered vs. unbuffered channels & avoiding deadlocks
Concurrency Patterns: select, sync & context
The tools that turn "it works" concurrency into production-grade concurrency.
selectfor waiting on multiple channels at oncesync.WaitGroup&sync.Mutexfor coordination & shared statecontextfor cancellation, timeouts & passing request-scoped values
Packages, Modules & Project Structure
Organize a Go project the way the ecosystem actually expects.
- Package naming, exported vs. unexported identifiers
- Conventional project layout for a real Go service
- Versioning & publishing a module,
go.sum& reproducible builds
Testing, Benchmarking & Table-Driven Tests
Testing is a first-class citizen of the toolchain — use it like one.
- The
testingpackage & the idiomatic table-driven test pattern - Mocking with interfaces & test coverage
- Benchmarks with
testing.B& readinggo test -benchoutput
Building a REST API with net/http
Ship an HTTP service using nothing but the standard library.
- Handlers,
ServeMux& routing requests without a framework - Encoding & decoding JSON request/response bodies
- Status codes, headers & graceful server shutdown
Middleware, Routers & API Design Patterns
The layer between "it works" and "it's an API other teams can depend on."
- Middleware chains for logging, auth & recovery
- A lightweight router (chi) for path params & route groups
- Consistent error responses & request validation
Working with Databases: database/sql & Migrations
Persist data the way most production Go services actually do.
- Connection pools, prepared statements & the
database/sqlinterface - Scanning rows into structs & handling
sql.ErrNoRows - Schema migrations & keeping them versioned alongside code
Error Handling at Scale, Logging & Observability
What "idiomatic errors" looks like once a service has real operational stakes.
- Wrapping errors with
%w& unwrapping witherrors.Is/errors.As - Structured logging with
slog - Basic metrics & tracing hooks for a production service
Deploying a Go Service: Docker & CI/CD
Ship the binary you built, not just run it on your laptop.
- Cross-compiling & building a minimal multi-stage Docker image
- Environment configuration & health-check endpoints
- A CI pipeline that builds, tests & publishes the image on every push
Performance & Profiling with pprof
Stop guessing where the time and memory are actually going.
- CPU & memory profiling with
net/http/pprof - Reading a flame graph & finding a real bottleneck
- Reducing allocations & avoiding premature optimization
Capstone: Build & Deploy a Production-Ready Go API
Apply every module in one project — a concurrent, tested, deployed Go service.
- A REST API with a real database, tests & middleware
- Containerized & deployed through a working CI/CD pipeline
- Portfolio-ready project you can show employers