Learning Path
What you will learn
This page is the map. You will see the seven stages of the course, what you build at the end of each one, and a simple routine to follow in every lesson so the material is still in your head next week.
You do not need prior Go experience. If you have written a little code in any language, you will move faster, but nothing here assumes it.
Why the order matters
Go topics lean on each other. Goroutines are confusing until functions and pointers feel natural. An HTTP server is confusing until you understand interfaces, because the core of Go's web server is an interface called http.Handler.
If you jump ahead, you meet five unfamiliar ideas at once and cannot tell which one is blocking you. This course introduces each idea just before you need it, so every lesson has exactly one new thing to learn.
The seven stages
| Stage | What you learn | What you build |
|---|---|---|
| 1. The language | Program structure, variables, control flow, functions, collections, structs, methods, interfaces, errors, pointers | A command-line task tracker |
| 2. Concurrency | Goroutines, channels, select, cancellation, mutexes, WaitGroup | A worker pool that shuts down cleanly |
| 3. The standard library | Files, JSON, HTTP, time, context, logging, testing | A small HTTP API with validation and tests |
| 4. Build and review | Reading other people's Go, revisiting earlier topics | Small projects of your own choosing |
| 5. Backend engineering | API design, middleware, SQL, transactions, authentication, observability, graceful shutdown | A production-style service |
| 6. Advanced behaviour | Reflection, profiling, fuzzing, deep concurrency, unsafe, cgo | Benchmarks and fuzz tests for earlier work |
| 7. Capstone projects | Combining everything | CLI task manager, concurrent URL checker, file-backed API, production REST API |
YOUR LEARNING PATH
Keep your momentum
Your progress is saved only in this browser. No account or database needed.
Course progress
0 of 63 lessons completed
Lessons
Find the next topic or revisit something you have finished.
Getting started
- IntroductionTo do
- InstallationTo do
- Your First ProgramTo do
- Modules and DependenciesTo do
- Advanced ModulesTo do
Go fundamentals
- Program StructureTo do
- Project StructureTo do
- Project LayoutTo do
- Variables and Data TypesTo do
- FunctionsTo do
- Control StatementsTo do
- PointersTo do
- Arrays and SlicesTo do
- MapsTo do
- Structs and MethodsTo do
- InterfacesTo do
- Error HandlingTo do
- Defined Types and Type AliasesTo do
- GenericsTo do
Concurrency
- Concurrency ModelTo do
- GoroutinesTo do
- ChannelsTo do
- Select and CancellationTo do
- SynchronizationTo do
Standard library
Backend development
- Backend RoadmapTo do
- HTTP API DesignTo do
- MiddlewareTo do
- ValidationTo do
- Application WiringTo do
- ObservabilityTo do
- Database SQLTo do
- TransactionsTo do
- Authentication and AuthorizationTo do
- Graceful ShutdownTo do
- Production ChecklistTo do
Advanced Go
Projects
- CLI — Domain and StorageTo do
- CLI — Commands and TestsTo do
- Project — CLI Task ManagerTo do
- URL Checker — Worker PipelineTo do
- URL Checker — Cancellation and TestsTo do
- Project — Concurrent URL CheckerTo do
- File store and concurrencyTo do
- HTTP layer and testsTo do
- File-backed notes APITo do
- Persistence and authenticationTo do
- Operations and releaseTo do
- Production REST API capstoneTo do
A few notes on the ordering:
- Concurrency comes after the language, not alongside it. Goroutines are Go's best-known feature, so people want to start there. Resist that. Concurrent code built on shaky basics is where the hardest bugs come from.
- Stage 4 is deliberately light. A second reading of interfaces or channels makes far more sense after you have used them in a project. Revisiting is part of the plan, not a sign you failed the first time.
- Stage 6 is optional on a first pass. Reflection and
unsafeare tools you reach for rarely. Know they exist, and come back when a real problem calls for them.
The study loop
Use the same six steps in every lesson. It feels slower than reading, but reading alone creates a feeling of understanding that disappears the moment you open an empty file.
- Predict. Before running an example, write down what you think it prints.
- Type it. Do not paste. Typing forces you to notice every character.
- Run it. Compare the result with your prediction. A wrong prediction is the most useful moment in the lesson.
- Change one thing. Rename a variable, swap a type, delete a line.
- Break it on purpose. Read the compiler error. Go's errors are precise, and learning to read them is a skill of its own.
- Explain it. Say it out loud or write two sentences without looking at the lesson.
Here is the loop applied to a one-line example:
fmt.Println(7 / 2)
Predict first. Many people expect 3.5. Run it and you get 3, because both numbers are integers and Go does integer division. Now change it to 7 / 2.0 and the answer becomes 3.5. Break it by writing var x int = 3.5 and read the error. Explain it: "Go picks the division type from the operand types, and it will not silently throw away a decimal part." That is five minutes, and you now understand something that a paragraph of reading would not have taught you.
When you are stuck
Stuck is normal, and it is also where learning happens. Use this order:
- Read the compiler error slowly, from the first line. Later errors are often caused by the first one.
- Reduce the problem. Delete code until you have the smallest program that still fails.
- Look up the exact symbol with
go doc fmt.Printlnor on pkg.go.dev. - If 15 minutes pass with no progress, write the question down precisely ("why does this slice print
[1 2 3]after I changed a copy?") and look for the answer to that question, not to the whole topic.
Suggested pace
| Time available | A useful daily target |
|---|---|
| 30 minutes | One concept and one tiny experiment |
| 60 minutes | One lesson and its practice task |
| 90+ minutes | One lesson, its practice, and progress on a project |
Consistency beats intensity. Twenty focused sessions teach more than one long weekend followed by two weeks away.
How to know you understand a topic
You are ready to move on when you can do four things without looking at the lesson: explain the idea in your own words, write a small example from memory, name one situation where it is useful and one common mistake, and make a reasonable first guess at what a related compiler error means.
If you can only recognise the topic when you see it, you have learned the vocabulary but not yet the skill. Do the practice task again tomorrow.
Start here
Begin with Introduction, then Installation, then Your First Program, and finally Modules and Dependencies.
Practice
Pick one topic you want to learn this week. Write four sentences: what you will read, what you will build, how you will test it, and how you will explain it.
Example for the topic "variables and types":
- Read: the variables lesson, plus
go doc strconv.Atoi. - Build: a temperature converter that reads a number from the command line and prints Celsius and Fahrenheit.
- Test: normal input (
100), zero, a negative number, and invalid input likeabc. - Explain: "Go will not convert between
intandfloat64automatically, because a silent conversion can lose information. I have to write the conversion myself, so I always see where precision changes."
Summary
The course moves from language basics to concurrency, the standard library, backend engineering, and finally projects, because each stage depends on the one before. In every lesson, use the same loop: predict, type, run, change, break, explain. Projects are the proof of understanding, since they force several ideas to work together under real constraints.