Getting Started

Learning Path

A practical roadmap for learning Go in the right order, with a study routine that makes it stick.

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.

Your goal is not to memorise the standard library. Your goal is to understand Go well enough to read the documentation, solve a problem, and spot code that is unsafe or unclear.

The seven stages

StageWhat you learnWhat you build
1. The languageProgram structure, variables, control flow, functions, collections, structs, methods, interfaces, errors, pointersA command-line task tracker
2. ConcurrencyGoroutines, channels, select, cancellation, mutexes, WaitGroupA worker pool that shuts down cleanly
3. The standard libraryFiles, JSON, HTTP, time, context, logging, testingA small HTTP API with validation and tests
4. Build and reviewReading other people's Go, revisiting earlier topicsSmall projects of your own choosing
5. Backend engineeringAPI design, middleware, SQL, transactions, authentication, observability, graceful shutdownA production-style service
6. Advanced behaviourReflection, profiling, fuzzing, deep concurrency, unsafe, cgoBenchmarks and fuzz tests for earlier work
7. Capstone projectsCombining everythingCLI 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%

0 of 63 lessons completed

Just getting started63 to go

Lessons

Find the next topic or revisit something you have finished.

Getting started
Go fundamentals
Concurrency
Standard library
Backend development
Advanced Go
Projects

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 unsafe are 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.

  1. Predict. Before running an example, write down what you think it prints.
  2. Type it. Do not paste. Typing forces you to notice every character.
  3. Run it. Compare the result with your prediction. A wrong prediction is the most useful moment in the lesson.
  4. Change one thing. Rename a variable, swap a type, delete a line.
  5. Break it on purpose. Read the compiler error. Go's errors are precise, and learning to read them is a skill of its own.
  6. 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:

  1. Read the compiler error slowly, from the first line. Later errors are often caused by the first one.
  2. Reduce the problem. Delete code until you have the smallest program that still fails.
  3. Look up the exact symbol with go doc fmt.Println or on pkg.go.dev.
  4. 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 availableA useful daily target
30 minutesOne concept and one tiny experiment
60 minutesOne lesson and its practice task
90+ minutesOne 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.

Feeling slow is normal. Go has a small surface area, but interfaces, pointers, cancellation, and concurrency only click through repeated use.

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.

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.

Copyright © 2026