golangtutorial
Start learning

Search and navigate

Pages

Start HereRoadmapTutorialsCheatsheetInterview QuestionsResources

Published tutorials

Building a REST API with Go: The Complete TutorialFan-Out Fan-In in Go: Parallel Work with ChannelsGeneric Functions in Go: Writing Reusable CodeGo Benchmarking: Measuring Performance with testing.BGo Channels: Communication Between GoroutinesGo Constraints: comparable, Ordered and Custom SetsGo Context: Cancellation, Deadlines, and Request ValuesGo HTTP Client: Timeouts, JSON, and Reliable RequestsGo HTTP Middleware: Build a Production ChainGo Interview Questions: 25 Answers That Show UnderstandingGo Mutex: Protecting Shared State from Race ConditionsGo net/http: Build an HTTP Server from ScratchGo select Statement: Multiplexing Channels ExplainedGo Tools You Need for a Reliable Development LoopGo Tutorial: From First Program to Backend FoundationsGo Type Parameters: Syntax and Constraints ExplainedGo Worker Pool Pattern: Bounded Concurrency at ScaleGo's Type System Deep Dive: Static Typing Done RightGolang Compilation and Execution ExplainedGolang Developer Salary 2026: US, UK and RemoteGolang File Structure for Modules and ApplicationsGolang Hello World and Your First Go ProgramGolang IDEs: Choose an Editor for Your WorkflowGolang Interfaces: What They Are and How to Use ThemGoroutine Leaks in Go: How to Detect and Prevent ThemGoroutines in Go: Concurrency Without LeaksHow to Download and Install Golang SafelyHow to Learn Golang with a Focused Study PlanIntegration Testing in Go: Testing Real BoundariesJSON in Go: Encoding, Decoding, and ValidationLearn Golang with a Practical Beginner CourseMocking in Go: Test Doubles Without Magicsync.WaitGroup in Go: Coordinating Multiple GoroutinesTable-Driven Tests in Go: The Idiomatic WayTesting in Go: Table Tests, HTTP, Fakes, and CoverageWhat Is Go and How Does a Go Program Work?Why Learn Golang and What Is Go Used For?Writing Unit Tests in Go: A Practical Guide
Open full search and filters →

Beginner to professional

The complete
Golang roadmap.

Start with lessons you can read now, then open the full map when you want to see every planned skill and specialist branch.

9
learning stages
95
skills mapped
23
lessons available

9 stages shown

Beginner

Learn the language foundations

0 of 8 available

Build fluency with Go syntax and the small set of language features used in everyday programs.

Variables, constants, and basic typesPlanned
Control flowPlanned
FunctionsPlanned
Arrays and slicesPlanned
MapsPlanned
Strings, bytes, and runesPlanned
PointersPlanned
Structs and methodsPlanned
Intermediate

Write idiomatic Go

3 of 13 available

Move from valid Go to clear, maintainable Go with explicit contracts and predictable failure handling.

Project and file structureRead lesson Type systemRead lesson InterfacesRead lesson
Error handling and wrappingPlanned
Defer, panic, and recoverPlanned
Generics and constraintsPlanned
Composition and dependency injectionPlanned

Language internals

Expertise branch

Deepen your mental model when performance or tooling work requires it.

Memory allocation and escape analysisPlanned
ReflectionPlanned
The runtime and garbage collectorPlanned

Developer tooling

Expertise branch

Build reliable local workflows before projects become large.

Formatting, vet, and lintingPlanned
Debugging Go programsPlanned
Code generationPlanned
Advanced

Build web services and APIs

5 of 13 available

Build standard-library services first, then add frameworks and protocols when requirements justify them.

HTTP serversRead lesson HTTP clientsRead lesson JSON encoding and validationRead lesson MiddlewareRead lesson REST API projectRead lesson
Authentication and authorizationPlanned
API versioning and documentationPlanned

Framework route

Expertise branch

Compare ecosystem abstractions after learning net/http.

GinPlanned
EchoPlanned
FiberPlanned

Service protocols

Expertise branch

Choose protocols based on clients, latency, and operational needs.

gRPC and Protocol BuffersPlanned
WebSocketsPlanned
GraphQLPlanned
Advanced

Store and move data

0 of 11 available

Learn database fundamentals before selecting drivers, query tools, caches, or message systems.

database/sqlPlanned
PostgreSQLPlanned
Transactions and isolationPlanned
Schema migrationsPlanned
Connection pools and timeoutsPlanned

Data access choices

Expertise branch

Add abstraction only when its tradeoffs fit the service.

sqlcPlanned
GORMPlanned
SQLitePlanned

Caching and messaging

Expertise branch

Scale reads and decouple work after mastering consistency basics.

RedisPlanned
KafkaPlanned
NATSPlanned
Professional

Ship production systems

0 of 14 available

Make services observable, secure, repeatable to deploy, and safe to operate under failure.

Configuration and secretsPlanned
Structured loggingPlanned
Metrics, tracing, and observabilityPlanned
Profiling and performancePlanned
Graceful shutdown and resiliencePlanned
Container imagesPlanned
CI/CDPlanned
Application securityPlanned

Cloud native

Expertise branch

Operate services on an orchestration platform when scale demands it.

KubernetesPlanned
Serverless GoPlanned
Infrastructure automationPlanned

Distributed systems

Expertise branch

Study failure modes before splitting a reliable monolith.

Microservice boundariesPlanned
Retries, backoff, and circuit breakersPlanned
Distributed consistencyPlanned
Professional

Choose a specialist branch

0 of 15 available

Specialize after the core path. Pick the branch that matches the systems and teams you want to work with.

CLI and developer tools

Expertise branch

Build portable command-line applications and tooling.

CLI architecturePlanned
CobraPlanned
Terminal interfacesPlanned

AI integration

Expertise branch

Build reliable services around models, streams, and retrieval.

Model API clientsPlanned
Streaming responsesPlanned
Vector search and RAGPlanned

Embedded Go

Expertise branch

Use TinyGo for constrained hardware and WebAssembly targets.

TinyGo fundamentalsPlanned
IoT devicesPlanned
WebAssemblyPlanned

Security engineering

Expertise branch

Build defensive tools and review Go applications for common risks.

Secure codingPlanned
Network security toolsPlanned
Supply-chain securityPlanned

Open source mastery

Expertise branch

Read, contribute to, and maintain production Go projects.

Reading large Go codebasesPlanned
Contributing to Go projectsPlanned
Library API designPlanned

How to use this roadmap

Move down the core path in order. Branches are optional depth, not prerequisites. A grey item describes a planned competency and is deliberately not a link until its lesson passes publication checks.

  • Published Open the lesson now
  • Planned Keep it on your learning checklist
  • Expertise branch Choose based on your goals

Golang roadmap questions

Practical guidance for choosing how far and where to go next.

Do I need to learn every item in this Golang roadmap?

No. Complete the core path through testing and web services, then choose only the database, production, and specialist branches that match the work you want to do.

How long does it take to learn Go?

A developer can learn basic Go syntax in a few weeks, but production skill comes from building, testing, deploying, and operating several real programs. Use the roadmap as an ordered practice guide rather than a deadline.

Should a beginner start with a Go framework?

Start with the standard library and net/http so routing, middleware, requests, responses, and cancellation are visible. Evaluate a framework later when its conventions or ecosystem solve a concrete project need.

Why are some roadmap items not clickable?

A roadmap item becomes a link only when its tutorial is published on Golang Tutorial. Unlinked items remain visible so the full learning sequence stays useful without sending readers to drafts or missing pages.

Which specialist branch should I choose?

Choose based on a project: CLI tools for developer tooling, cloud native for operated services, AI integration for model-backed products, embedded Go for constrained devices, or security for defensive engineering.