Stage 1 · Code
Closing the Loop
Where to Go From Here
You finished the course. Here is an honest map of what you now know, what you still do not, and which path actually makes sense next.
What You Can Actually Do Now
Sixteen modules ago, this course started with go run . printing a single line. It ends with you able to write a generic data structure, coordinate goroutines through channels and context.Context without racing yourself, build and test a JSON API with net/http, talk to a real database through database/sql with migrations and transactions, build a live terminal dashboard with Bubble Tea and Lip Gloss, and reach for reflection, cgo, or build tags on the rare occasions a program actually needs them. That is not a beginner skill set anymore. It is a working, professional one.
More importantly, you built three real things end to end: the tasker CLI in module 6, a capstone tool you scoped, laid out, configured, and shipped yourself in module 8, and burnrate — a live terminal dashboard built with Bubble Tea and Lip Gloss in module 16. Those three projects are proof, to you and to anyone who asks, that you can take a problem from an empty directory to a binary someone else can run — including one with a real, interactive interface.
- You can read and write idiomatic Go: structs, interfaces, methods, error values, generics, and the standard library patterns around all of them.
- You can reason about concurrency correctly — goroutines, channels, select, sync primitives, worker pools, and cancellation with context — instead of guessing and hoping the race detector stays quiet.
- You can build and test an HTTP JSON service, including middleware, table-driven tests, and httptest-based handler tests.
- You can connect that service to a real database: raw SQL, connection pooling, migrations, transactions, and a sane caching strategy.
- You can build a live, interactive terminal UI with Bubble Tea and Lip Gloss, keeping the underlying logic pure and testable independent of the screen.
- You can ship a CLI as a real artifact: cross-compiled binaries, checksummed release archives, and a README a stranger could actually follow.
The Gaps This Course Did Not Close
A complete course is not one that pretends to cover everything. It is one that is honest about its edges. This course deliberately stayed inside the language, its standard library, and a single service talking to a single database. That was the right scope for building real fluency — but it means a few important areas were left for other, more focused courses instead of being rushed here.
| Area | Why it is not here | Where it belongs |
|---|---|---|
| Data structures & algorithm depth | Trees, graphs, heaps, and dynamic programming deserve their own progression, not a rushed detour mid-language-course. | Data Structures & Algorithms in Go |
| Coding-interview specific practice | Whiteboard framing, timed problem drills, and interview communication are a distinct skill from writing production Go, and deserve their own dedicated course rather than a token module bolted onto the end of this one. | A future, dedicated interview-preparation course |
| Distributed systems & platform operations | Kubernetes, service meshes, multi-service architectures, and SRE practices are their own discipline built on top of a language, not part of learning the language. | This academy's cloud, Kubernetes, and SRE tracks |
Interview preparation and language fluency are genuinely different skills — one is about solving unfamiliar problems under time pressure and communicating your reasoning out loud, the other is about writing correct, maintainable software. Mixing them made both weaker. A focused interview-prep course, built the same deliberate way as this one, is a better home for that material than a single module at the end of a language course.
Pick a Direction
You do not need to do everything next. Pick the path that matches what you actually want to build or the kind of role you are aiming at.
- Want to get sharper at problem-solving and algorithms? Move to Data Structures & Algorithms in Go — it assumes exactly the Go fluency you just built.
- Want to build bigger backend systems? Continue into Building Backend Applications, where single-service patterns grow into multi-service architecture.
- Want to move toward reliability and operations? The SRE Playbook and Observability & Monitoring courses pick up where a single well-built service leaves off.
- Want to keep building? The best next step for a lot of people is simply picking a slightly bigger version of the capstone tool you already shipped, and building it again — a little more ambitiously this time.
Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.