Web development · 5 stages · about 44 weeks
Backend developer (Go) roadmap
0/26 tasks done (ticks are kept on this device)
- 1
Beginner · about 6 weeks
Go basics and modules
What to learn
Go language basics: Go is small, so you can learn the whole language quickly.
Learn variables, types, if/else, for loops (Go has only one kind of loop), functions and multiple return values. Go is compiled, which means it turns your code into one program file that runs fast. Start with the free Tour of Go in your browser.
Slices and maps: These hold most of the data in Go programs.
A slice is a growable list, like a list of order amounts. A map stores values by key, like stock count by product name. Learn how append works and why a slice shares memory with the array underneath it.
Structs and methods: Structs are how you model real things in Go.
A struct groups related fields, like a Customer with Name, Phone and City. You can attach methods to a struct, such as Total() on an Invoice. Go has no classes or inheritance; it builds bigger things by putting structs inside structs.
Interfaces: Interfaces make Go code flexible and easy to test.
An interface lists methods, and any type that has those methods fits it automatically. For example, anything with a Read method is an io.Reader. Keep interfaces small, often with just one or two methods.
Error handling: Go handles errors in a plain, visible way.
Functions return an error value, and you check it with if err != nil right after the call. Add context when you pass an error up, with fmt.Errorf and %w. This style is wordy, but it makes it clear where things can fail.
Go modules and packages: Modules manage your project and its dependencies.
go mod init creates a go.mod file that names your module and lists the packages you use. Code is split into packages (folders), and names that start with a capital letter are visible outside the package. Search pkg.go.dev to find packages and read their docs.
Go tools: Go comes with built-in tools that every team uses.
go fmt formats your code the standard way, so every Go project looks the same. go vet finds common mistakes, and go test runs tests. Learn to read compiler errors calmly; they are usually very clear.
Tasks
Project
A command-line stock tracker for a small shop in Go: add items, sell items, warn when stock is low, and save everything to a JSON file, with clear error messages and go fmt, go vet and go test passing.
Free resources
- 2
Beginner · about 8 weeks
HTTP APIs with net/http and PostgreSQL
What to learn
HTTP and REST basics: Most Go backends serve HTTP APIs.
A request has a method (GET, POST, PUT, DELETE), a URL, headers and often a JSON body. The server answers with a status code like 200, 201, 400 or 404. In REST, each thing has its own URL, like /orders/42.
net/http: Go's standard library is strong enough for real web servers.
net/http gives you a server, a router (ServeMux) and handlers, which are functions that answer requests. Since Go 1.22 the router understands methods and path values, like GET /orders/{id}. Many Go teams use only the standard library or a light router like chi.
JSON in Go: APIs send and receive JSON.
The encoding/json package turns structs into JSON and back. Struct tags like `json:"name"` set the field names. Always check decoding errors and reject unknown or missing fields where it matters.
Middleware: Some code must run for every request, like logging and auth.
Middleware is a function that wraps a handler and runs code before or after it. Common uses are logging, recovering from panics, checking login tokens and adding request ids. Keep each middleware small and focused.
SQL and PostgreSQL: Most Go services store data in PostgreSQL.
A SQL database keeps data in tables. Learn SELECT, INSERT, UPDATE, DELETE, WHERE, JOIN and GROUP BY. PostgreSQL is free, reliable and the most common choice with Go.
database/sql, pgx and sqlc: This is how Go code talks to the database.
database/sql is Go's standard database interface, and pgx is a popular, fast PostgreSQL driver. sqlc reads your SQL queries and writes type-safe Go functions for them. Always use query parameters, never build SQL by joining strings, to block SQL injection.
Migrations and config: Database changes and settings must be managed safely.
Migration tools like goose or golang-migrate keep numbered SQL files that change the database step by step. Settings and secrets go in environment variables, not in code. Never commit passwords to GitHub.
Tasks
Project
A REST API for a small pharmacy or kirana shop: products, stock, customers and orders with GST, written with net/http, PostgreSQL, sqlc and migrations, with clean JSON errors.
📘 Learn it here, free: Backend Development course
Free resources
- 3
Intermediate · about 10 weeks
Concurrency, testing, auth and Docker
What to learn
Goroutines: Goroutines are the main reason companies choose Go.
A goroutine is a very light task that runs at the same time as others; you start one with the go keyword. A Go server can run thousands of them cheaply. But you must make sure they finish and do not leak.
Channels and select: Channels let goroutines pass data safely.
A channel is a pipe: one goroutine sends a value and another receives it. select waits on several channels at once, for example a result or a timeout. Learn common patterns like worker pools and fan-out, fan-in.
sync and race conditions: Shared data used by many goroutines can break in strange ways.
A race condition happens when two goroutines change the same data at the same time. Use sync.Mutex to protect shared data and sync.WaitGroup to wait for goroutines to finish. Run tests with the -race flag to find these bugs.
context: context stops work that is no longer needed.
A context carries a deadline or a cancel signal through your code. If a user closes the page, the request context is cancelled and your database query can stop too. Pass ctx as the first argument to functions that do slow work.
Testing in Go: Go has testing built in, and teams expect you to use it.
Tests live in _test.go files and run with go test. Table-driven tests check many inputs and outputs in one loop. The httptest package lets you test handlers without starting a real server.
Authentication: Most APIs need login and permissions.
Hash passwords with bcrypt or argon2, never store them as typed. Use sessions or JWTs (signed tokens) to remember the user, and check permissions on every route. Use well-known libraries for crypto instead of writing your own.
Docker: Go programs fit very well in small Docker images.
A Go program builds into one file, so the final image can be tiny. Use a multi-stage Dockerfile: build in a Go image, then copy only the program into a small base image. Docker Compose can start your API and PostgreSQL together.
Structured logging with slog: Clear logs make production problems much easier to find.
The log/slog package writes logs as key-value pairs or JSON. Add a request id and user id to every log line. Never log passwords, tokens or card numbers.
Tasks
Project
A price-tracking service: a background worker pool checks product prices from several sources on a schedule, stores history in PostgreSQL, exposes a REST API with login, and runs in Docker Compose with tests and slog logs.
📘 Learn it here, free: Backend Development course
Free resources
- 4
Intermediate · about 8 weeks
gRPC, services and observability
What to learn
Protocol Buffers: Protobuf is a compact, typed way to describe data between services.
You write message shapes in a .proto file, and a tool creates Go code for them. Protobuf messages are smaller and faster than JSON. Field numbers must never be reused, so old and new versions can still talk.
gRPC: Many Go companies use gRPC for fast service-to-service calls.
gRPC lets one service call a function on another service as if it were local. It runs on HTTP/2 and supports streaming in both directions. Use deadlines on every call, so one slow service does not freeze the others.
Caching and queues: Services need to stay fast and handle slow work in the background.
Redis is often used as a cache and for rate limiting. Message systems like NATS or Kafka let services send events, such as "order placed", without waiting. Make consumers safe to run twice on the same event.
Metrics with Prometheus: Numbers tell you how healthy a service is.
Metrics are numbers over time, like requests per second, error count and response time. The Prometheus client library exposes them on a /metrics page, and Grafana draws graphs from them. Many Kubernetes tools are written in Go and use Prometheus.
Tracing with OpenTelemetry: Traces show the path of one request across many services.
A trace records each step of a request, like the API call, the gRPC call and the database query, with timings. OpenTelemetry is the open standard for collecting traces, metrics and logs. Pass context through every call so the trace stays connected.
Graceful shutdown and health checks: Services must stop and start cleanly during deploys.
On a stop signal, stop taking new requests, finish the current ones, then close database connections. Add /healthz and /readyz endpoints so the platform knows when the service is alive and ready. This prevents lost requests during updates.
Tasks
Project
A two-service order system: a REST order API that calls a gRPC inventory service, events for "order placed", Prometheus metrics, OpenTelemetry traces, health checks and graceful shutdown, all in Docker Compose.
Free resources
- 5
Expert · about 12 weeks
Kubernetes, performance and system design
What to learn
Kubernetes: Go services usually run on Kubernetes, which is itself written in Go.
Kubernetes runs and scales containers across many machines. Learn Pods, Deployments, Services, ConfigMaps, Secrets and probes. Set resource requests and limits so one service cannot starve the others.
Profiling with pprof: Senior Go engineers find slow code by measuring, not guessing.
pprof shows where your program spends CPU time and memory. Benchmarks (go test -bench) measure a function before and after a change. Learn how the garbage collector works and how to reduce memory allocations in hot code.
Advanced concurrency: Large systems need careful control of many goroutines.
Use errgroup to run related tasks and stop all of them if one fails. Limit how many tasks run at once so you do not overload the database. Watch for goroutine leaks with pprof and good tests.
System design: Most Go roles are mid or senior level and test design skills.
Learn load balancing, database replicas, caching, queues, rate limiting and eventual consistency. Practise designs such as a URL shortener, a notification service or a live cricket score system. Always explain trade-offs and what happens when parts fail.
Reliability practices: Platform teams are measured by uptime.
SLOs (service level objectives) set a clear target, such as 99.9% of requests under 300 ms. Use retries with backoff, circuit breakers and timeouts everywhere. Write blameless reviews after incidents to stop them happening again.
Writing CLI tools and operators: A lot of Go work is building tools for other engineers.
Go is great for command-line tools because it builds one file that runs anywhere. Libraries like Cobra help with commands and flags. Advanced engineers write Kubernetes operators, which are programs that manage other apps inside the cluster.
Leading and reviewing: Senior engineers shape how the whole team works.
Write short design documents before big changes. Review code kindly and point to Go's own style guides, like Effective Go. Help teammates who are coming to Go from Java or Python learn its simple style.
Tasks
Project
A production-style notification platform: a gRPC API, a queue, worker services with rate limits per channel, PostgreSQL, metrics, traces and SLO alerts, deployed on Kubernetes, with a design document and a load-test report.
Free resources