---
title: "Roadmap Go 2026: 6 Meses do Zero ao Mercado"
url: "https://golang.com.br/aprenda/roadmap-go-2026/"
markdown_url: "https://golang.com.br/aprenda/roadmap-go-2026.MD"
description: "Roadmap completo de Go em 2026: 6 meses, 6 fases, 1 projeto por mês. Do hello world a APIs em produção, com recursos em pt-BR e os assuntos que aparecem em entrevistas."
date: "2026-01-29"
author: ""
---

# Roadmap Go 2026: 6 Meses do Zero ao Mercado

Roadmap completo de Go em 2026: 6 meses, 6 fases, 1 projeto por mês. Do hello world a APIs em produção, com recursos em pt-BR e os assuntos que aparecem em entrevistas.


# Roadmap Go 2026: 6 Meses do Zero ao Mercado

Plano direto. Seis meses, seis fases, um projeto por mês. Cada fase vem com o que ler, o que codar, e o que aparece em entrevista. Sem rodeios.

A meta no final dos 6 meses: você consegue sustentar uma conversa técnica sobre Go com um sênior, tem 3-4 projetos públicos no GitHub e está pronto pra pleitear vagas júnior/pleno. Pessoas que vêm de outra linguagem normalmente cortam isso pela metade.

## Como usar este roadmap

- **8–10h por semana** é o ritmo realista pra quem trabalha. Mais que isso, ótimo. Menos, esticar.
- **Cada fase termina com um projeto.** Não pula. Saber a teoria sem ter codado é a maior armadilha.
- **Marque os links que aparecem aqui.** São o currículo do curso. O resto é internet.
- **Tudo é gratuito.** Não tem nada nesse roadmap que você precise pagar.

Pronto? Bora.

---

## Fase 1 — Fundamentos (Semanas 1–4)

O básico. Sintaxe, tipos, controle de fluxo, funções, structs, packages.

### O que aprender

- Variáveis, tipos básicos, constantes, `iota`
- `if`, `for`, `switch`, `defer`
- Funções, retorno múltiplo, named returns, variadic
- Arrays, slices, maps — e a diferença entre eles
- Structs, métodos, ponteiros
- Packages, `go.mod`, imports
- Conversão de tipos, type assertions
- Como usar `go run`, `go build`, `go fmt`, `go vet`

### Recursos

- **[A Tour of Go](https://go.dev/tour/)** — interativo, oficial, tem versão em português. Faça duas vezes.
- **[Go by Example](https://gobyexample.com/)** — exemplos curtos com explicação. Cada conceito vira um snippet executável.
- **[Effective Go](https://go.dev/doc/effective_go)** — leia depois das duas primeiras semanas, vai fazer mais sentido.
- **[Effective Go em 2026](/blog/effective-go-2026/)** — o que ainda vale, o que mudou e como completar a leitura para Go moderno.
- **[Como aprender Go (em pt-BR)](/aprenda/como-aprender-go/)** — guia complementar de quem já passou pelo caminho.
- **[Go para iniciantes](/aprenda/go-para-iniciantes/)** — primeiro hello world + servidor HTTP em 15 minutos.

### Projeto: CLI de TODO

Um aplicativo de linha de comando que adiciona, lista e marca tarefas como completas. Persiste em um arquivo JSON. Ensina structs, slices, leitura/escrita de arquivos, e empacotar uma binary.

### O que cai em entrevista

- Diferença entre `array` e `slice`. O que é o `cap`?
- Como funciona o `defer`?
- Quando usar ponteiro vs valor em receivers?
- O que é `nil` em Go? Quando faz sentido comparar?

---

## Fase 2 — Biblioteca padrão (Semanas 5–8)

Go vem com bateria. Quase tudo que outras stacks tratam como "framework" o stdlib resolve — `fmt`, `strings`, `time`, `os`, `io`, `encoding/json`, `errors`. Aprenda a procurar antes de instalar.

### O que aprender

- `fmt` — formatação, `Sprintf`, verbos (`%v`, `%+v`, `%T`, `%w`)
- `strings`, `strconv`, `unicode`, `bytes`
- `time` — duração, formatação, timezones, comparações
- `os`, `io`, `bufio`, `path/filepath` — leitura/escrita de arquivos, stdin/stdout
- `encoding/json`, `encoding/csv` — marshal/unmarshal, struct tags
- `errors` — `errors.Is`, `errors.As`, `fmt.Errorf` com `%w`, custom error types
- `log/slog` — o logger estruturado oficial (Go 1.21+)
- `flag` — parsing de argumentos de linha de comando

### Recursos

- **[Standard library docs](https://pkg.go.dev/std)** — a referência oficial, organizada por package.
- **[Tutorial Go modules](/aprenda/go-modules-na-pratica/)** — como organizar dependências e packages.
- **[Tratamento de erros em Go](/aprenda/golang-erros/)** — o jeito Go de fazer erros (e por que não tem `try/catch`).

### Projeto: Conversor de logs

CLI que lê logs em formato A (CSV, plain text, JSON Lines), normaliza pra um schema único e escreve em formato B. Adiciona flags pra filtros (por data, por nível). Exercita stdlib pesado.

### O que cai em entrevista

- Diferença entre `errors.Is` e `errors.As`?
- Por que erros em Go são valores e não exceções?
- Como você lê um arquivo grande sem carregar tudo na memória?
- O que `time.Now().UTC()` retorna?

---

## Fase 3 — HTTP, APIs e JSON (Semanas 9–12)

Aqui o stdlib do Go brilha mais. `net/http` foi desenhado pra ser usado em produção sem framework. Você aprende a montar API REST, middlewares, e a manejar JSON com confiança.

### O que aprender

- `net/http` — handlers, middlewares, mux (Go 1.22+ tem padrões avançados de routing)
- Server vs client (sim, dá pra fazer requests também)
- Headers, cookies, query params, path params
- JSON encoding/decoding com structs e tags
- Validação de input
- `context.Context` — pra cancelar requests, passar dados de request scope
- HTTP middleware pattern (logging, auth, recovery)
- HTTPS, TLS básico

### Recursos

- **[API REST com Go](/aprenda/api-rest-go/)** — guia completo, do hello world a CRUD em produção.
- **[Tutorial em 4 partes com Gin](/aprenda/api-rest-gin-parte1/)** — se preferir começar com framework.
- **[net/http docs](https://pkg.go.dev/net/http)** — leia a doc inteira do package, vale a pena.
- **["How I write HTTP services" — Mat Ryer](https://grafana.com/blog/2024/02/09/how-i-write-http-services-in-go-after-13-years/)** — uma das leituras mais influentes da comunidade.

### Projeto: API REST de URL shortener

POST cria um link curto, GET redireciona, DELETE remove. Bonus: usa SQLite pra persistir (vai ser usado de novo na fase 5). Exercita HTTP, JSON, validação, error responses.

### O que cai em entrevista

- Como você implementaria um middleware de logging?
- Diferença entre `http.Handler` e `http.HandlerFunc`?
- Como cancela um request HTTP em curso?
- Pra que serve o `context.Context`?

---

## Fase 4 — Concorrência (Semanas 13–16)

A razão de Go existir. Goroutines + channels é o modelo que vendeu a linguagem pro mercado. É também a parte que distingue júnior de pleno em entrevista.

### O que aprender

- Goroutines — o que são, custo, quando usar
- Channels — buffered vs unbuffered, direção, fechamento
- `select` — multiplexação, timeout, default
- `sync.WaitGroup`, `sync.Mutex`, `sync.RWMutex`, `sync.Once`
- `context.Context` (de novo, agora pra cancelamento de goroutines)
- Patterns: worker pool, fan-out/fan-in, pipeline
- Race detector (`go run -race`)
- Quando NÃO usar goroutines

### Recursos

- **[Concorrência em Go (pt-BR)](/aprenda/concorrencia-go/)** — overview com exemplos.
- **[Go Concurrency Patterns — Rob Pike (vídeo)](https://www.youtube.com/watch?v=f6kdp27TYZs)** — a palestra clássica. 50 minutos bem gastos.
- **[Advanced Go Concurrency Patterns](https://www.youtube.com/watch?v=QDDwwePbDtw)** — Sameer Ajmani. Continuação natural do Pike.
- **[Visualizing concurrency](https://divan.dev/posts/go_concurrency_visualize/)** — animações que ajudam a internalizar o modelo.

### Projeto: Web crawler concorrente

Recebe uma URL, busca a página, extrai todos os links, e processa cada um em paralelo (com limite de profundidade e respeito a `robots.txt`). Saída: árvore de links em JSON. Exercita goroutines, channels, sync, context.

### O que cai em entrevista

- Diferença entre `sync.Mutex` e channel?
- O que é race condition? Como o detector funciona?
- Como você implementa um worker pool com N workers?
- Quando um channel deve ser fechado, e por quem?

---

## Fase 5 — Bancos de dados e migrações (Semanas 17–20)

Aplicação real precisa persistir. Go tem `database/sql` no stdlib, drivers maduros pra todos os bancos populares, e ferramentas modernas como `sqlc` que dão type-safety sem ORM.

### O que aprender

- `database/sql` — connection pool, prepared statements, scan
- Driver de PostgreSQL (`pgx` é o padrão hoje) ou MySQL
- Transactions, savepoints
- Migrations (`golang-migrate` ou `goose`)
- `sqlc` — gera código Go type-safe a partir de SQL
- Connection pool tuning
- N+1 queries (e como evitar)
- Padrões: repository, query builder

### Recursos

- **[Go + PostgreSQL na prática (pt-BR)](/aprenda/golang-postgresql/)** — setup, queries, transactions.
- **[sqlc docs](https://docs.sqlc.dev/)** — a abordagem moderna. Aprenda essa.
- **[Mat Ryer no Twitter sobre repositories](https://twitter.com/matryer)** — siga, ele posta padrões úteis com frequência.

### Projeto: URL shortener (de novo, com banco)

Pega o projeto da fase 3 e migra de "salva tudo em memória" pra PostgreSQL. Adiciona migration, sqlc, transactions onde fizer sentido. Exercita persistência real.

### O que cai em entrevista

- Diferença entre `Query`, `QueryRow` e `Exec`?
- Como evitar SQL injection?
- O que é connection pooling?
- Quando usar transaction?

---

## Fase 6 — Testes, produção e deploy (Semanas 21–26)

A diferença entre código que funciona e código que aguenta produção. Aqui você fecha o ciclo: testar de verdade, observar o que está rodando, e empacotar pra rodar em qualquer lugar.

### O que aprender

- `testing` package — table-driven tests, subtests, helpers
- Mocks (com `gomock`, `testify/mock`, ou interfaces e stubs manuais)
- Cobertura de testes (`go test -cover`)
- Benchmarks (`testing.B`, `go test -bench`)
- `httptest` pra testar handlers HTTP
- `log/slog` em produção — structured logging
- `prometheus/client_golang` — métricas
- OpenTelemetry — tracing distribuído
- `context.Context` pra cancelamento e timeout em produção
- Graceful shutdown (signals, drain de connections)
- Configuração via env vars (`os.Getenv`, ou `kelseyhightower/envconfig`)
- Dockerfile multi-stage para Go
- Deploy: railway, fly.io, ou Cloud Run pra começar

### Recursos

- **[Testes em Go (pt-BR)](/aprenda/testes-go/)** — fundamentos + table-driven.
- **[Go com Docker (pt-BR)](/aprenda/golang-docker/)** — multi-stage build, imagem mínima.
- **["Standard Go Project Layout" — golang-standards](https://github.com/golang-standards/project-layout)** — como organizar repos Go em produção. Polêmico mas útil de conhecer.

### Projeto: API observável em produção

Pega o URL shortener da fase 5 e leva pra produção real. Adiciona: testes (cobertura > 70%), logging estruturado, métricas Prometheus, healthchecks (`/livez`, `/readyz`), Dockerfile, deploy num provedor (fly.io ou railway). Bonus: configura GitHub Actions pra testar e fazer deploy.

### O que cai em entrevista

- O que é table-driven test?
- Como você testaria código que faz HTTP request pra um terceiro?
- O que é graceful shutdown? Por que importa?
- Como você descobriria se uma rota está lenta em produção?

---

## Depois dos 6 meses

A essa altura você tem repertório pra começar a se especializar. Três caminhos clássicos pra dev Go no Brasil:

- **Backend / SaaS** — APIs grandes, microserviços, event-driven. Empresas: Nubank, iFood, Mercado Livre, PicPay.
- **Plataforma / DevOps / SRE** — infra como código, Kubernetes operators, internal tools. Empresas: Stone, Wildlife, qualquer fintech séria.
- **Distributed / dados** — Kafka, streaming, ETL pesado. Empresas: Cloudflare (remoto), HashiCorp, qualquer fintech ou marketplace.

Comece olhando vagas dessas categorias e trabalhe de trás pra frente: o que aparece toda hora nos requisitos? Estuda isso. Aplica.

## Próximos passos

- 📚 Leitura recomendada: **["The Go Programming Language" — Donovan & Kernighan](https://www.gopl.io/)**. O livro de referência. Lê em paralelo com o roadmap.
- 💼 Aplica pra **[vagas Go abertas no Brasil](/vagas/)** desde a fase 4. Mesmo júnior. Praticar leitura de job description é parte do estudo.
- 🎯 Prepara entrevista com **[50 perguntas comuns de Go](/aprenda/perguntas-entrevista-go/)**.
- 💰 Cheque **[salários por seniority](/carreira/salarios-go-brasil/)** pra calibrar expectativas.
- 🛠️ Tenha um **[cheatsheet de sintaxe](/cheatsheet/)** aberto enquanto coda.

Boa jornada. Cada commit é um passo a mais. 🚀