For people asking what to build to really learn Go, here’s a progression that maps well to how Go actually teaches you pragmatic systems thinking, concurrency, and production discipline.
---
Simple (start here, learn fundamentals & clarity)
1. Build a CLI tool (flag parsing, file I/O, error handling)
2. Build a log processor (bufio, streaming, memory efficiency)
3. Build a small HTTP client (net/http, retries, timeouts)
4. Build a basic HTTP server (handlers, middleware, context)
5. Build an in-memory cache (maps, mutexes, TTL)
6. Build a file watcher (fsnotify, goroutines, channels)
7. Build a config loader (env vars, YAML/JSON, validation)
8. Build a worker pool (goroutines, channels, backpressure)
---
Medium (where Go’s concurrency model clicks)
9. Build a REST API service (routing, middleware, graceful shutdown)
10. Build a job queue (channels vs persistent queues, retries)
11. Build a rate limiter (token bucket, leaky bucket)
12. Build a reverse proxy (net/http, connection reuse)
13. Build a metrics exporter (Prometheus client, counters, histograms)
14. Build a scheduler (cron-style, timers, cancellation)
15. Build a simple key-value store (files, WAL concepts)
16. Build an auth service (JWT, middleware, context propagation)
17. Build a search service (inverted index, concurrency-safe reads)
---
Hard (production-grade Go & systems depth)
18. Build a high-throughput TCP server (epoll-style patterns, pooling)
19. Build a distributed worker system (leader election, coordination)
20. Build a sharded cache (hashing, consistency trade-offs)
21. Build a Raft-based service (state machines, persistence)
22. Build a storage engine (indexes, compaction, snapshots)
23. Build a streaming pipeline (fan-in, fan-out, backpressure)
24. Build a custom protocol (binary framing, versioning)
25. Build a service mesh sidecar (proxies, retries, observability)
26. Build a full backend platform (API, async jobs, caching, metrics)
---
You learn Go by:
- Designing simple APIs
- Handling failure explicitly
- Respecting concurrency costs
- Writing code others can read at 3am
If your code feels boring, obvious, and stable then believe me, you’re doing it right.
For people asking what to build to really learn Rust, here’s a progression that maps well to how Rust actually teaches you systems thinking.
Simple (start here, learn ownership & basics)
1. Build a CLI tool (argument parsing, file I/O, error handling)
2. Build a log parser (iterators, lifetimes, zero-copy parsing)
3. Build a small HTTP client (reqwest async basics)
4. Build a basic TCP server (std::net, threading)
5. Build an LRU cache (HashMap linked list, ownership pain included)
6. Build a file watcher (inotify-style logic, channels)
7. Build a config loader (serde, enums, validation)
8. Build a simple thread pool (Mutex, Arc, Condvar)
---
Medium (where Rust really clicks better)
9. Build an async web server (tokio, hyper, backpressure)
10. Build a key-value store (LSM-style, WAL, file layouts)
11. Build a job scheduler (work queues, cancellation, timeouts)
12. Build a reverse proxy (async I/O, connection pooling)
13. Build a mini database index (B-tree or skip list)
14. Build a parser AST (nom or handwritten parser)
15. Build a WASM runtime toy (wasmtime concepts)
16. Build an auth service (JWT, crypto crates, zero-copy serialization)
17. Build a search engine (inverted index, mmap, ranking)
---
Hard (deep Rust systems mastery)
18. Build a memory allocator (unsafe, layout, alignment)
19. Build a container runtime (namespaces, cgroups concepts)
20. Build a distributed cache (networking, consistency trade-offs)
21. Build a Raft implementation (ownership state machines)
22. Build a storage engine (MVCC, snapshots, compaction)
23. Build a network protocol (custom framing, async streams)
24. Build a compiler backend (IR, borrow checker inspiration)
25. Build an OS kernel module or toy kernel (no_std, bare metal)
26. Build a database from scratch (query planner execution engine)
---
Rust rewards building, not watching tutorials. So keep building too.
Each project forces you to confront ownership, lifetimes, concurrency, and performance head-on.
If it hurts a little(especially those borrow checkers errors), you’re doing it right.