SM - Go

What skills does a Go developer need?

It depends what kind of service you're shipping

The skills a Go developer needs depend on what they're building. Anyone writing backend services and APIs needs to be comfortable with interfaces, error handling, and a web framework like Gin or Echo, plus enough SQL and an ORM like GORM to talk to a database. Developers working on cloud-native and infrastructure tooling — the space Go was built for — lean heavily on goroutines, channels, and the concurrency patterns behind tools like Docker and Kubernetes.

If CLI tools are the focus, frameworks like Cobra and a solid grasp of the standard library's I/O and flag packages matter more than any web framework. Across all of these, generics and Go's type system come up more often as codebases grow.

Universally, Go rewards writing simple, explicit code — strong error handling instead of exceptions, table-driven tests, and comfort with the toolchain (go vet, pprof, race detector) that keeps a concurrent program correct and fast.

The Go Roadmap

Work through these in order, then pick a framework or tool that matches the service you're building

STEP 1

Introduction & Setup

Why Go exists, and getting your first program running.

Documentation

Why use Go History of Go Setting up the Environment Hello World in Go go command

STEP 2

Language Basics & Data Types

Variables, constants, and the built-in types everything else is made of.

Variables & Constants var vs := Zero Values const and iota Scope and Shadowing Boolean Numeric Types Integers (Signed, Unsigned) Floating Points Complex Numbers Runes Strings Raw & Interpreted String Literals Type Conversion

STEP 3

Composite Types

Arrays, slices, maps, and structs — Go's building blocks for structured data.

Arrays Slices Capacity and Growth make() Slice ⇄ Array Conversion Maps Comma-Ok Idiom Structs Struct Tags & JSON Embedding Structs

STEP 4

Control Flow & Functions

How Go branches, loops, and packages logic into functions.

if / if-else / switch for loop for range Loops Iterating Maps Iterating Strings break / continue goto (discouraged) Functions Basics Variadic Functions Multiple Return Values Anonymous Functions Closures

STEP 5

Pointers & Memory

Share and mutate data without copying it, and let the garbage collector do the rest.

Pointers Basics Pointers with Structs Named Return Values Call by Value Call by Value with Maps & Slices Garbage Collection

STEP 6

Methods, Interfaces & Generics

Go's take on polymorphism — implicit interfaces and, more recently, generics.

Methods vs Functions Pointer Receivers Value Receivers Interfaces Basics Empty Interfaces Embedding Interfaces Type Assertions Type Switch Why Generics? Generic Functions Generic Types / Interfaces Type Constraints Type Inference

STEP 7

Error Handling

Go's explicit, no-exceptions approach to things going wrong.

Error Handling Basics error interface errors.New fmt.Errorf Wrapping / Unwrapping Errors Sentinel Errors panic and recover Stack Traces & Debugging

STEP 8

Code Organization & Modules

Structure a codebase and manage dependencies the Go way.

Modules & Dependencies go mod init go mod tidy go mod vendor Packages Package Import Rules Using 3rd Party Packages Publishing Modules

STEP 9

Concurrency

Goroutines and channels — the feature Go is best known for.

Goroutines Channels Buffered vs Unbuffered Select Statement Worker Pools sync Package Mutexes WaitGroups context Package Deadlines & Cancellations Fan-In / Fan-Out / Pipeline Race Detection

STEP 10

Standard Library, Testing & Benchmarking

What ships in the box, and how to prove your code actually works.

I/O & File Handling flag time encoding/json os bufio slog regexp go:embed testing package basics Table-Driven Tests Mocks and Stubs httptest Benchmarks Coverage

STEP 11

Ecosystem & Popular Libraries

Pick a lane — CLI, web service, or something else — and go deep on the tools for it.

STEP 12

Go Toolchain & Tools

Build, lint, profile, and ship — the commands you'll run daily.

go run go build go install go fmt go mod go test go clean go doc go version go generate Build Tags go vet goimports revive staticcheck golangci-lint govulncheck pprof trace Race Detector Cross-Compilation Building Executables

STEP 13

Advanced Topics

Push past what most Go code ever needs to touch.

Memory Management in Depth Escape Analysis Reflection Unsafe Package Build Constraints & Tags CGO Basics Compiler & Linker Flags Plugins & Dynamic Loading

GitHub Projects

Real, buildable projects to put on your own GitHub

REST API with Gin

Build a JSON REST API on top of the Gin framework, with your own routes, middleware, and error handling — a direct follow-up to Steps 7 and 11.

Web Framework REST API Error Handling

CLI Tool with Cobra

Scaffold a command-line tool with Cobra, add subcommands and flags, then package it into a cross-compiled binary — practice for Steps 11 and 12.

CLI Cobra Cross-Compilation

Official Go Example Programs

Work through the Go team's own example programs — an HTTP server, string utilities with tests, and more — to see idiomatic testing and package layout.

Standard Library Testing Idioms

Frequently Asked Questions

Common questions from people starting out with Go

Do Go and Golang refer to the same language?

Yes. The language's official name is Go, but golang.org was used as the project's early domain (go.org wasn't available), and "Golang" stuck as the informal name people search for — the two terms refer to the exact same language.

When should I use a goroutine vs a plain function call?

Reach for a goroutine when work can run independently of the current flow — handling a request, waiting on I/O, or fanning out to multiple sources at once. If the work has to finish before the next line runs, a plain function call is simpler and avoids the coordination overhead of channels or WaitGroups.

What's the difference between a slice and an array in Go?

An array has a fixed size baked into its type and is copied by value. A slice is a lightweight view over an underlying array that can grow, gets passed around by reference, and is what you'll use in almost all everyday Go code — arrays mostly show up as the thing slices are built on top of.

How does Go handle errors instead of exceptions?

Go functions return an error value alongside their result, and callers check it explicitly instead of catching thrown exceptions. panic and recover exist for truly exceptional situations, but idiomatic Go treats errors as ordinary values to be checked, wrapped, and returned up the call stack.

Do I need a web framework, or is net/http enough?

The standard library's net/http and routing added in newer Go versions can carry a surprisingly complete API on their own. Frameworks like Gin, Echo, or Fiber earn their keep once you want built-in middleware, faster routing, or conventions for larger teams — but plenty of production services run on net/http alone.

How do I prepare for a Go interview?

Be ready to explain goroutines, channels, and how the sync package fits in; know the difference between value and pointer receivers; and be comfortable with Go's error-handling conventions. Having built one concurrent program — a worker pool or pipeline — that you can walk through in detail is one of the strongest things you can bring.

Track complete

From syntax and interfaces to goroutines, tooling, and a production-ready service — that's the core of what employers expect from a Go developer. Keep building, and let the direction you enjoy most (backend, CLI, or infrastructure) pull you toward the next roadmap.

Where next?

Keep exploring by domain or drill into a single skill

Browse by Domain

Role-based roadmaps like Backend, DevOps, and AI/ML Engineer.

Browse by Skill

Go deep on one tool at a time — Kubernetes, Terraform, Git, and more.