Goroutines and pgx pools are easy to fake in a tutorial; here you prove them on a service with traces, metrics, and a clean drain.
You can read Go. That is not the problem. The problem is the gap between a tutorial's main.go and the thing your team actually runs: a binary that reads config from the environment, opens a pgx pool that does not exhaust under load, serves chi routes behind middleware, emits OTel spans and slog JSON, and drains in-flight requests when Kubernetes sends SIGTERM. This course closes that gap across 100 challenges. Module 1 starts at `go version` and ends with a static Linux binary cross-compiled from your laptop. From there: zero values and escape analysis, interfaces with no `implements` keyword, errors as values with `%w` wrapping, goroutines and `context` cancellation checked by the race detector, the stdlib I/O surface, table-driven tests and fuzzing, `internal/` boundaries the compiler enforces, Postgres with pgx and golang-migrate, chi servers with graceful shutdown, and asynq workers with dead-letter queues. The capstone is `linkr`, a URL shortener you bring up with one docker-compose command and load-test to a p95 redirect under 5 ms cached.
Built by Lakshya Kumar
Paste this into any AI chat. Fill in the bracketed parts with your context — you'll get back a straight answer on whether this belongs on your plate.
We grant free access case-by-case — students, career-switchers, builders on a tight budget. Sign in to send us a note.
Sign in to applyFinished the tasks? Take the prompt to your AI and get tested on it. We copy the prompt and open the app — just paste it in.
Zero values, implicit interfaces, pointer receivers, and `%w` wrapping — the habits that stop your Go reading like translated Java.
Channels, `select`, and `context` cancellation under `-race`, so the goroutine you spawn actually stops when the request does.
io.Reader composition, struct tags, client timeouts, and the default-mux footgun — everything you get before reaching for a framework.
Table-driven subtests, httptest, fuzzing, and benchmarks from the stdlib alone — with plain interfaces standing in for every mock.
cmd/ and internal/, multi-binary repos, build tags, //go:embed, and the lint findings you would rather catch before code review.
Pool limits, parameterized queries, `defer tx.Rollback()`, and embedded migrations — plus what pool exhaustion looks like at 2am.
Subrouters, middleware composition, request-scoped context, JSON validation, and Redis rate limits — a server you can restart mid-traffic.
asynq and river queues, cron with leader election, jittered backoff, and dead-letter replay for the jobs that fail while you sleep.
slog JSON, RED metrics, OTel propagation, distroless multi-stage builds, and probes that tell your orchestrator the truth.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Build `linkr`, a URL shortener service in Go. Required: chi router, pgx + Postgres for link storage, Redis for hot-cache and rate-limiting, an asynq worker that sweeps expired links and aggregates click analytics, OTel traces, Prometheus `/metrics`, structured `log/slog` JSON logs, graceful SIGTERM shutdown that drains in-flight redirects, and a `docker-compose.yml` that brings up the whole stack in one command. Submit: the repo URL, a Loom or asciinema of the docker-compose start-to-redirect flow, and a load-test (`oha` or `wrk`) showing p95 redirect latency under 5 ms cached.
I'm considering Capstok's "Go: From Zero to Production Service" course. It covers the toolchain, types and interfaces, goroutines + channels + context, stdlib I/O, testing, project layout, Postgres with pgx, HTTP servers with chi, background workers, and full production architecture (OTel, slog, Docker). Capstone is a URL shortener. Context about me: 1. My current role/focus: [e.g. "Python backend dev", "frontend engineer crossing over", "self-taught"] 2. The closest I've come to Go before: [e.g. "never written it", "tutorials only", "small CLI"] 3. What I want to be able to do at the end: [e.g. "ship a Go service at work", "pass a Go interview", "write Kubernetes operators"] Answer: - For my background, which 2 modules will pay back fastest in the next 3 months and why? - A concrete bug I'm likely to ship in my first Go service that this course would catch. - Is 45 hours worth it for me, or should I learn TS/Python deeper first? Honest pick. - What this course explicitly will NOT teach me (e.g. Kubernetes ops, gRPC internals)?
The book. Pre-generics but every concept is still current.