go-patterns
esc

Track

Go developer roadmap

The first 3 stages are the same for every Go developer, starting at go mod init. After that the path branches by the kind of work you want to do.

Choose a track

Backend and APIs

3 stages

HTTP and gRPC services people depend on.

CLI and developer tools

viewing

Single binaries other engineers install.

Cloud-native and platform

planned

Controllers, operators, and the control plane.

AI agents in Go

planned

Tool dispatch, retrieval, memory, evals.

CLI and developer tools

draft 7 stages · 42 topics

Go's other native habitat: one static binary, no runtime to install, and a command line that has to make sense to someone who has never read your code. Ends with a tool you can tag and release.

0 of 42 topics checked

The first three stages are shared, so ticking them here counts on every track.

Before stage 01

None of this is Go, and all of it shows up in your first week on a Go team.

Git and code review

Branches, rebase, small commits, and reading a diff — you will learn Go through pull requests.

Terminal and Linux basics

Shell navigation, environment variables, processes, signals, file permissions, and SSH.

HTTP and JSON

Methods, status codes, headers, caching, and what a request actually looks like on the wire.

SQL and data modeling

Joins, indexes, transactions, and normalization — most Go services are database services.

The path

Topic — click to check off Done Distance travelled

Start
01

Language Foundations

0/6

2–4 weeks

Read and write plain Go without looking up syntax on every line.

Build A CLI that reads a cart as JSON on stdin and prints an itemized order total with tax and shipping.

Move on when You can explain the difference between a nil slice and an empty slice, and why a value receiver cannot mutate its struct.

02

Idiomatic Go

0/6

3–5 weeks

Write code a Go reviewer recognizes as Go — not translated Java or Python.

Build A catalog package with an interface-based repository, an in-memory fake, and table-driven tests covering the domain rules.

Move on when You introduce an interface only when there is a second implementation or a test double — never speculatively.

03

Concurrency and Context

0/6

4–6 weeks

Write concurrent code that is correct under -race, not merely faster.

Build A supplier price fetcher that queries N suppliers concurrently with a per-request deadline, cancels the rest once enough quotes arrive, and leaks no goroutines.

Move on when You can spot a goroutine leak in review and explain why context beats a shared done flag.

04

Command Surface

0/6

3–4 weeks

Design a command line someone else can learn without reading the source.

Build A catalog CLI with add, list and export subcommands that round-trips through stdin and stdout, and exits non-zero with a message you could act on.

Move on when Someone can pipe your tool into jq and script it without reading the source.

05

Tools People Install

0/6

4–6 weeks

Ship a binary a stranger can install, trust, and upgrade.

Build Tag and release the catalog CLI for three platforms with checksums, a --version that reports the real commit, and output that stays readable when piped.

Move on when Your tool behaves the same in CI as in a terminal, and you never hand-build a release.

06

Tool Craft

0/6

ongoing

Make the tool safe to run on someone else's machine and easy to change.

Build Add a golden-file suite and a --verbose debug mode to the catalog CLI, then cut startup time or binary size with before/after evidence.

Move on when You can change the output format without fear, because the golden tests catch it.

07

Design and Architecture

0/6

ongoing

Make design decisions you can defend — including the patterns you rejected.

Build Refactor a tangled package behind one clear interface boundary using the patterns in this catalog, and write the short design doc that justifies the split.

Move on when You can explain why a pattern was the wrong fit as clearly as why another one was right.

Finish

After this the road is just build, measure, review — on repeat.

Patterns for this track

Patterns are not a stage you complete — they are vocabulary you pick up once you have code worth reorganizing. These are the ones this track runs into most.

Command

Encapsulate operations for queuing, audit history, and undo/redo while keeping Go error handling explicit.

Builder

Separate a multi-step construction workflow from the final representation so the same input can produce different outputs cleanly.

Composite

Treat individual objects and object groups uniformly so recursive tree structures stay simple to traverse and aggregate.

Template Method

Define the skeleton of an algorithm once while letting concrete steps vary through narrow hook methods.

Memento

Capture and restore object state without exposing internal details so undo and rollback remain explicit and controlled.

Interpreter

Define a small grammar for recurring business rules and evaluate sentences of that grammar with an expression tree.

Resources worth your time

A short list, mostly official. Finish these before buying a course.

A Tour of Go

The official interactive introduction. Finish it before anything else.

Effective Go

How Go is meant to be written, straight from the Go team.

Go Code Review Comments

The checklist Go reviewers actually apply to your pull requests.

Go by Example

Short annotated programs for nearly every language feature.

The Go Blog

Canonical deep dives on slices, errors, context, generics, and the GC.

Standard Library Reference

Bookmark it. Reading std source is part of learning the language.

Learn Go with Tests

Learn the language test-first — the fastest route to testing discipline.

Go Proverbs

Rob Pike's one-liners that explain most Go design arguments.

Traps on the way

Shopping for frameworks before you know what net/http already does.
Defining an interface for every struct — abstraction without a second implementation.
Starting goroutines with no context, no cancellation, and no owner.
Discarding errors with _ or logging and continuing as if nothing happened.
Using panic for control flow instead of returning wrapped errors.
Growing a utils or common package that everything imports.
Splitting into microservices before a single service is under strain.
Copying Java or C# class hierarchies into Go and calling it a design pattern.