14. What's Next

🎁 You know Go. Now the real question: how do you go from "I finished a course" to "I can build production systems in Go"? The answer is deliberate practice with a concrete plan.

The Gap Between Learning and Doing

Finishing this course means you understand Go's concepts. It doesn't mean you can build production software quickly yet. That gap closes through building real things, not reading more.

The goal for the next 12 weeks is not to know every Go feature. The goal is:

"I can build and explain production-style systems in Go."

Assume ~45-60 minutes a day, 5 days a week.

One of Go's biggest advantages: the standard library covers almost everything you need. net/http, encoding/json, sync, os, io, context, testing. You can build serious production software without pulling in a single external dependency. Use this to your advantage.

Weeks 1-2: Fluency (Stop Looking Everything Up)

You've seen all the concepts. Now internalize them by writing code without looking everything up.

Build:

• CLI file analyzer (count lines, words, characters per file — os, bufio, flag)
• Log parser (read a log file, filter by level, output counts — strings, regexp)
• Configuration loader (read a JSON or TOML config file, decode into structs — encoding/json)

Focus on:

• Error handling patterns — no panic in production paths, always return error
• Writing idiomatic Go: short variable names, flat code, explicit over clever
• os.Args, flag, and fmt for CLI tools
• Table-driven tests with testing

Do not spend days reading the spec. Write code, break it, fix it, read the error messages.

Weeks 3-4: Real Tooling

Build:

• Parallel file scanner (walk a directory, collect stats concurrently — filepath.Walk, goroutines, channels)
• HTTP JSON API client (fetch data, parse responses, handle errors — net/http, encoding/json)
• Process monitor (list running processes, output as JSON — os/exec, encoding/json)

Focus on:

• goroutines and channels for concurrency
• context for cancellation and timeouts
• encoding/json for marshaling/unmarshaling
• sync.WaitGroup and sync.Mutex
• Writing benchmarks with testing.B

A small project to tie it together:

syswatch
├── CPU and memory stats    (os, runtime)
├── top processes           (os/exec)
├── disk usage              (syscall)
└── JSON output             (encoding/json)

No external packages needed.

Weeks 5-6: HTTP Services

Go's net/http standard library is production-grade. No framework needed to build real services.

Build:

• REST API (CRUD endpoints, JSON request/response, proper status codes)
• Middleware chain (logging, auth, rate limiting — using http.Handler and http.HandlerFunc)
• Graceful shutdown (catch signals, drain connections — os/signal, context)

Focus on:

• http.Handler interface and middleware composition
• context propagation through request handlers
• sync.Once for initialization
• net/http/httptest for testing handlers

// Everything you need for a production HTTP service
import (
    "context"
    "encoding/json"
    "net/http"
    "os/signal"
    "syscall"
)

Weeks 7-8: Concurrency Patterns

This is where Go's design pays off most visibly.

Build:

• Worker pool (N goroutines processing a shared job channel)
• Pipeline (producer → transformer → consumer using channels)
• Rate limiter (time.Ticker, token bucket — no external package)
• Fan-out / fan-in aggregator

Focus on:

• Channel direction (chan<-, <-chan)
• select for multiplexing
• context.WithTimeout and context.WithCancel
• Avoiding goroutine leaks

Compare what you're writing to goroutine patterns you've seen. Go's concurrency model is the most readable of any language — lean into it.

Weeks 9-10: Production Patterns

This is where you move from "it works" to "it works reliably."

Build:

• Reliable job queue with retry, timeout, and backoff (all stdlib)
• Structured logger (wrap log/slog — added in Go 1.21)
• Config loader with environment variable overrides (os.Getenv, encoding/json)

Focus on:

• log/slog for structured logging (Go 1.21+)
• Error wrapping with fmt.Errorf("context: %w", err) and errors.Is / errors.As
• Writing integration tests with net/http/httptest
• Benchmarking with go test -bench

This is the kind of project you can discuss in depth in interviews. Be able to explain every design decision.

Weeks 11-12: One Serious Project

Pick one and finish it. A half-finished project teaches you nothing about production Go.

Option A: Developer platform tool

• Internal CLI for deployment workflows
• Log aggregation agent
• Health check dashboard

Option B: Infrastructure component

• In-memory key-value store with HTTP API
• Task scheduler with cron syntax
• Rate-limited reverse proxy (net/http/httputil)

Option C: Data processing tool

• Log/event processing pipeline
• File format converter
• Concurrent web crawler (net/http, golang.org/x/net/html)

Whatever you pick, add:

• A README explaining what it does and how to run it
• Tests (unit and integration)
• Benchmarks for anything performance-sensitive
• CI (GitHub Actions with go test ./... and go vet)

This is your portfolio piece. You should be able to walk someone through the code in 20 minutes and explain every decision.

Practice Alongside (Every Week)

Don't wait until week 12 to start interview preparation.

Every week:

• 2-3 LeetCode problems in Go (arrays, strings, trees — the fundamentals)
• 1 system design topic reviewed

Your Go muscle memory builds through repetition. The sooner you write Go daily, the sooner it stops feeling foreign.

Standard Library Worth Knowing

Learn each one when a project demands it. You'll naturally reach for most of them in weeks 1-8.

Key Takeaways

• Finishing a course gives you concepts. Projects give you skill.
• Go's standard library is unusually complete — reach for it before adding dependencies
• Build in order: CLI tools → HTTP services → concurrent systems → production patterns
• No framework needed: net/http + encoding/json + context is enough for real services
• Practice LeetCode in Go weekly — don't wait until you feel "ready"
• One finished serious project is worth ten half-built ones