Skip to content

Table of Contents

🗺️ Go From Zero — Six-Month Roadmap

A complete, day-by-day plan to go from zero to production-grade Go backend engineer in ~180 days (6 months × 4 weeks × ~7 days). Plan for 1.5–3 focused hours/day.

How to read this: Each month has objectives, outcomes, weekly breakdowns, and assessments. Month 1 is expanded to full daily detail as the worked example; Months 2–6 give week-level plans with daily themes — generate each day's note from templates/DAILY_TEMPLATE.md (or ./scripts/new-day.sh) following the same rhythm.

Table of Contents

Legend & Daily Rhythm

Difficulty: 🟢 beginner · 🟡 intermediate · 🔴 advanced Each day follows this rhythm (~2h):

  1. Learn (30–45m) — read the day's source material.
  2. Build (45–60m) — write the day's code in the relevant folder.
  3. Practice (20–30m) — exercises / challenge.
  4. Explain & Recall (10–15m) — write the day note, self-quiz, fill the reflection.
  5. Commit — one conventional commit using the day's suggested message.

Primary references (used all six months): A Tour of Go, Effective Go, Go by Example, Std lib, Google Go Style Guide. Books: The Go Programming Language (Donovan & Kernighan, "K&D"), Learning Go (Jon Bodner), 100 Go Mistakes (Teiva Harsanyi). Full list in RESOURCES.md.

Month 1 — Go Fundamentals

Theme: Read, write, and reason about idiomatic Go programs. Be comfortable with the toolchain.

Field Detail
Objectives Install & use the Go toolchain; understand syntax, types, functions, structs, methods, interfaces, errors; write & run small programs and tests.
Expected outcome Can build, run, format, and test a multi-file Go module; can explain interfaces and error handling.
Skills go CLI, modules, formatting, basic testing, debugging with prints/delve.
Concepts Types & zero values, slices/maps, structs/methods, interfaces, errors, packages, modules.
Project projects/01-cli-todo — a CLI todo app with JSON persistence.
Reading Learning Go ch. 1–7; Effective Go (top half); A Tour of Go (all).
Videos Go in 100 Seconds; [Tour of Go walkthroughs]; [JustForFunc] early episodes.
Official docs How to Write Go Code, Tour, Effective Go.
Practice exercises/month-01/*, Exercism Go track (10+ exercises), Gophercises.
Interview Qs interview/go-language.md Q1–Q20.
Review/Assessment Weekly reviews + end-of-month quiz (closed-book): explain slices vs arrays, value vs pointer receivers, interface satisfaction, error wrapping.
Milestones ✅ First commit · ✅ First passing test · ✅ CLI todo v1 · 🏷️ tag v0.1.0.
Portfolio additions CLI todo project + README; "I can write idiomatic Go" resume line.
Target confidence Reach ⅗ on Go syntax & tooling.

Week 1 — Setup, Syntax & Types

  • Topics: install Go, go mod, gofmt, go run/build, variables, constants, iota, basic types, operators, control flow.
  • Goals: run your first program; understand declarations and zero values.
  • Exercises: exercises/month-01/week-1/ — FizzBuzz, temperature converter, simple calculator.
  • Reading: Learning Go ch.1–3; Tour: Basics.
  • Mini project: a greeting CLI that takes a -name flag.
  • Checkpoint: explain the difference between var, :=, and const; what a zero value is.
Day Objective Build Challenge Commit
001 Toolchain & first program examples/hello/ Hello, Go; init a module print your name & Go version chore: set up repo and first Go program
002 Variables, constants, iota examples/vars/ demo all declaration forms reimplement an enum with iota feat(examples): variables, constants, iota
003 Numeric & string types, conversions conversions demo; strconv basics temperature converter CLI feat(examples): types and conversions
004 Control flow (if, for, switch) loops & switch demos FizzBuzz + classic patterns feat(exercises): control-flow drills
005 Functions, multiple returns, defer function demos; defer order a divmod function returning (q, r, err) feat(examples): functions, multiple returns, defer
006 Packages & modules split code into a package a small reusable mathutil package refactor: extract mathutil package
007 Week 1 review clean up week's code; run go vet/gofmt redo FizzBuzz from memory (active recall) docs(journal): week 1 review

Week 2 — Composite Types

  • Topics: arrays, slices (len/cap/append/copy), maps, strings/runes/bytes, structs.
  • Goals: internalize slice mechanics (the #1 beginner gotcha) and struct basics.
  • Exercises: word-count map, slice filter/map/reduce, in-place slice delete/insert.
  • Reading: Learning Go ch.3–4; Go Slices: usage & internals.
  • Mini project: a contacts book (struct + slice + map index).
  • Checkpoint: explain why appending to a slice can mutate another slice; nil map read vs write.
  • Daily themes: 008 arrays & slice basics · 009 slice internals (cap/append aliasing) · 010 slice tricks (filter/insert/delete) · 011 maps & sets · 012 strings, runes, bytes, UTF-8 · 013 structs & struct tags · 014 Week 2 review + recall quiz.

Week 3 — Methods, Interfaces & Errors

  • Topics: methods, value vs pointer receivers, method sets, interfaces, type assertions/switches, the error interface, wrapping (%w, errors.Is/As), panic/recover.
  • Goals: design with small interfaces; handle errors idiomatically.
  • Exercises: define a Shape interface; a custom error type; a JSON-ish stringer.
  • Reading: Effective Go (interfaces, errors); 100 Go Mistakes (errors chapter).
  • Mini project: a geometry package with Shape interface + tests.
  • Checkpoint: when does a type satisfy an interface? value vs pointer receiver method sets.
  • Daily themes: 015 methods & receivers · 016 interfaces & satisfaction · 017 type assertions & switches · 018 errors as values + wrapping · 019 custom errors, sentinel errors, errors.Is/As · 020 panic/recover & when to use them · 021 Week 3 review.

Week 4 — Composition, Generics & Project

  • Topics: struct embedding/composition, interface embedding, generics (type params, constraints, comparable), the empty interface vs any, building the CLI project.
  • Goals: ship project #1; write your first table-driven tests.
  • Reading: Tutorial: generics; Learning Go ch.8.
  • Project: build projects/01-cli-todo end to end.
  • Checkpoint: Month-1 assessment (closed-book quiz) + ship the project + tag v0.1.0.
  • Daily themes: 022 embedding & composition · 023 generics fundamentals · 024 generic data structures (stack/set) · 025 project: model + storage · 026 project: CLI commands · 027 project: tests + README · 028 Month 1 review, tag v0.1.0, portfolio update.

Month 2 — Standard Library, Tooling & Testing

Theme: Master the std lib and prove your code with tests, benchmarks, and tooling.

Field Detail
Objectives Fluent use of fmt, strings, strconv, time, io, bufio, os, encoding/json, net/http (client), log/slog, flag; write table-driven tests, benchmarks, and fuzz tests; use go vet, golangci-lint, pprof.
Expected outcome Can build a tested CLI/HTTP client tool with structured logging and CI.
Skills Testing, benchmarking, profiling, linting, JSON/IO handling, structured logging.
Concepts io.Reader/Writer, JSON (un)marshaling, time handling, table-driven tests, coverage, fuzzing, benchmarks.
Project projects/02-url-shortener (with a full test suite + SQLite).
Reading Learning Go ch.9–11, 15; 100 Go Mistakes (testing, std lib).
Practice Exercism (intermediate), exercises/month-02, advent-of-code-style IO puzzles.
Interview Qs interview/stdlib-and-runtime.md, interview/go-language.md Q21–Q40.
Assessment Reach ≥70% coverage on the project; write one benchmark + one fuzz test.
Milestones ✅ First CI pipeline green · ✅ First benchmark · 🏷️ tag v0.2.0.
Portfolio additions Tested URL shortener; "TDD + CI" resume line.
Target confidence 3.5/5 std lib & testing.
  • Week 1 — IO & formatting: io.Reader/Writer, bufio, os, fmt verbs, strings/strconv/bytes, strings.Builder. Mini: a wc/grep clone. (cmd/, files, pipes.)
  • Week 2 — Encoding, time & HTTP client: encoding/json (tags, custom marshalers), time, net/http client, context timeouts, log/slog. Mini: a weather/JSON-API CLI client.
  • Week 3 — Testing deep dive: table-driven tests, subtests, t.Parallel, httptest, coverage, testify, benchmarks, fuzzing, examples. Retrofit tests onto Month-1 code.
  • Week 4 — Tooling & project: go vet, golangci-lint, Makefile, build tags, pprof quickstart, GitHub Actions CI; build the URL shortener with SQLite + tests. Tag v0.2.0.

Month 3 — Concurrency & Parallelism

Theme: The thing Go is famous for. Goroutines, channels, and the patterns that don't leak.

Field Detail
Objectives Use goroutines, channels, select, the sync package, context, and errgroup; recognize and fix races, deadlocks, and goroutine leaks; implement worker pools, fan-in/fan-out, pipelines, and graceful shutdown.
Expected outcome Can design a correct, cancellable concurrent program and prove it race-free with -race.
Skills Concurrency patterns, race detection, profiling concurrent code, the GMP scheduler mental model.
Concepts Goroutines, channels & axioms, select, mutex/atomic, context cancellation, pipelines, semaphores, the memory model.
Project projects/04-concurrent-web-crawler.
Reading Concurrency in Go (Katherine Cox-Buday); K&D ch.8–9; Go blog: pipelines; 100 Go Mistakes (concurrency).
Practice Build a worker pool, rate limiter, and bounded semaphore from scratch; exercises/month-03.
Interview Qs interview/concurrency.md (all).
Assessment Crawler runs race-clean (go test -race), cancels via context, and shuts down gracefully.
Milestones ✅ Zero -race warnings · ✅ Graceful shutdown · 🏷️ tag v0.3.0.
Portfolio additions Concurrent crawler; "designed leak-free concurrent systems" talking point.
Target confidence 3.5/5 concurrency.
  • Week 1 — Goroutines & channels: goroutines, unbuffered vs buffered channels, channel axioms, select, time.After, deadlocks. Mini: ping-pong & generator.
  • Week 2 — sync & memory model: Mutex/RWMutex, WaitGroup, Once, Pool, atomic, the race detector, the Go memory model. Mini: a concurrent-safe cache.
  • Week 3 — Patterns: worker pools, fan-in/fan-out, pipelines, bounded parallelism/semaphores, context cancellation, errgroup, rate limiting (golang.org/x/time/rate).
  • Week 4 — Project: build the concurrent web crawler with worker pool + context + graceful shutdown + tests. Profile it. Tag v0.3.0.

Month 4 — Web, REST APIs & Databases

Theme: Build real HTTP services backed by a real database.

Field Detail
Objectives Build idiomatic REST APIs with net/http + chi; middleware; request validation; persistence with PostgreSQL (database/sql/pgx, sqlc, golang-migrate); transactions; layered architecture; integration tests with testcontainers.
Expected outcome A documented, tested CRUD REST API with auth, migrations, and CI.
Skills HTTP routing/middleware, REST design, SQL, migrations, validation, integration testing, JWT auth.
Concepts Handlers/middleware, context propagation, connection pooling, transactions, repository pattern, DTOs vs domain models.
Project projects/03-rest-api-bookstore.
Reading Let's Go & Let's Go Further (Alex Edwards) — the canonical Go web books; Organizing a Go module.
Practice Add pagination, filtering, rate limiting, and JWT auth; exercises/month-04.
Interview Qs interview/backend-and-databases.md.
Assessment API passes integration tests (testcontainers Postgres); OpenAPI documented; handles errors with proper status codes.
Milestones ✅ First REST API · ✅ DB migrations · ✅ JWT auth · 🏷️ tag v0.4.0.
Portfolio additions Flagship-candidate REST API with full README + diagram.
Target confidence ⅘ backend web dev.
  • Week 1 — HTTP foundations: net/http server, http.Handler/HandlerFunc, routing with chi, middleware, JSON request/response helpers, error handling, graceful shutdown.
  • Week 2 — Databases: database/sql + pgx, connection pooling, sqlc, migrations (golang-migrate), the repository pattern, transactions, context deadlines.
  • Week 3 — Real-world concerns: validation, structured logging per-request, pagination/filtering, configuration (env/viper), rate limiting, JWT auth + middleware, RBAC basics.
  • Week 4 — Project: build the Bookstore API end to end with layered architecture, integration tests, OpenAPI docs, Dockerfile, CI. Tag v0.4.0.

Month 5 — gRPC, Architecture & Microservices

Theme: Service-to-service communication and clean, testable architecture.

Field Detail
Objectives Define & serve gRPC (protobuf, unary + streaming, interceptors); compare REST vs gRPC; apply Hexagonal/Clean Architecture and dependency injection; split into microservices; add Redis caching.
Expected outcome A gRPC microservice with a clean, port-and-adapter architecture and an ADR log.
Skills protobuf/gRPC, interceptors, architecture (ports & adapters), DI, caching, inter-service comms.
Concepts RPC vs REST, streaming, deadlines/metadata, domain-driven boundaries, dependency inversion, cache-aside.
Projects projects/05-grpc-microservice, projects/06-job-queue-redis.
Reading gRPC Go docs; 100 Go Mistakes (architecture); Hexagonal Architecture (Alistair Cockburn); ADR.
Practice Convert the Month-4 REST API's core into a gRPC service; write ADRs for key decisions.
Interview Qs interview/backend-and-databases.md (gRPC), interview/system-design.md.
Assessment Service builds from .proto, has interceptors (logging/auth), and is unit-testable via injected ports.
Milestones ✅ First gRPC service · ✅ First ADR · ✅ Redis cache · 🏷️ tag v0.5.0.
Portfolio additions gRPC microservice + architecture diagram + ADRs.
Target confidence ⅘ architecture & gRPC.
  • Week 1 — gRPC basics: protobuf, protoc/buf, code generation, unary + server/client/bidi streaming, deadlines & metadata, errors/status codes.
  • Week 2 — Interceptors & gateway: logging/auth/recovery interceptors, TLS, grpc-gateway/REST transcoding, reflection, testing gRPC.
  • Week 3 — Architecture & DI: hexagonal/ports-and-adapters, dependency injection (manual + wire), domain modeling, ADRs, Redis cache-aside, config.
  • Week 4 — Projects: build the gRPC microservice + the Redis-backed job queue; document architecture with diagrams + ADRs. Tag v0.5.0.

Month 6 — Production, Observability & Capstone

Theme: Ship something production-grade you'd be proud to put at the top of your résumé.

Field Detail
Objectives Add observability (slog, Prometheus metrics, OpenTelemetry tracing, health checks); containerize and deploy; CI/CD; security hardening; performance tuning; then build the capstone.
Expected outcome A deployed, observable, documented, multi-tenant SaaS backend — the portfolio flagship.
Skills Observability, Docker/compose, CI/CD, profiling & tuning, security (govulncheck/gosec), graceful ops.
Concepts The three pillars (logs/metrics/traces), SLOs, 12-factor config, multi-stage builds, load testing, threat modeling.
Project projects/07-capstone-saas-backend.
Reading Cloud Native Go (Matthias Stadler/M. Titmus); OpenTelemetry Go docs; Prometheus docs; 12-Factor App.
Practice Load-test with k6/vegeta; profile & cut allocations; run govulncheck; write runbooks.
Interview Qs interview/system-design.md, interview/devops-docker-redis.md, full interview/ review.
Assessment Capstone deploys via CI/CD, exposes metrics + traces + health, passes security scan, has unit + integration tests, and a complete README + ADRs.
Milestones ✅ Dockerized · ✅ Metrics + traces · ✅ CI/CD deploy · ✅ Capstone shipped · 🏷️ tag v1.0.0 + release.
Portfolio additions Pinned flagship capstone; updated résumé bullets; interview talking points doc.
Target confidence 4.5/5 production Go.
  • Week 1 — Observability: structured logging (slog), Prometheus metrics (client_golang), OpenTelemetry tracing, /healthz & /readyz, correlation IDs, dashboards.
  • Week 2 — Containerization & CI/CD: multi-stage Docker, docker-compose, image hardening, GitHub Actions build/test/scan/deploy, secrets/config, graceful shutdown & signals.
  • Week 3 — Performance & security: pprof CPU/heap profiling, escape analysis, sync.Pool, load testing, govulncheck/gosec, input validation, authn/authz hardening, rate limiting.
  • Week 4 — Capstone: build & deploy projects/07-capstone-saas-backend; write the final README, architecture docs, ADRs, and demo; tag v1.0.0; publish a wrap-up post. Graduation. 🎓

Confidence Self-Assessment Scale

Rate yourself after each month (record in PROGRESS.md).

Score Meaning
1 Aware of the concept; can't use it unaided.
2 Can use it by copying examples/docs.
3 Can use it from memory for common cases.
4 Can apply it to novel problems and explain trade-offs.
5 Can teach it, debug subtle cases, and design with it.

⬅ Back to README · Track it in PROGRESS.md · Log it in LEARNING_LOG.md