Roadmap Go-разработчика 2025-2026: от 0 до Middle 3

Обзорный документ для тех, кто хочет понять путь Go-разработчика в РФ/СНГ Актуально на 2026 год

1. Введение

Кто такой Go-разработчик в 2026

Go-разработчик в 2026 году — это в основном бэкенд-инженер, работающий с высоконагруженными системами. К 2026 году Go окончательно закрепился как стандарт де-факто для:

Бэкенд-разработки в финтехе, e-commerce, телекоме (Т-Банк, Ozon, Avito, Яндекс)
Облачной инфраструктуры (Kubernetes, Docker, Terraform, Prometheus — всё написано на Go)
DevOps / SRE (инструменты, утилиты, контроллеры)
Микросервисной архитектуры — Go вытеснил Java и Python в нише высокопроизводительных микросервисов
Embedded / IoT — реже, но растущее направление
CLI-утилит и сетевых сервисов (gRPC, REST, WebSocket)

Где работают Go-разработчики

Топ-индустрии (РФ/СНГ):

Финтех — Т-Банк, Сбер, Альфа, Райффайзен
E-commerce и маркетплейсы — Ozon, Wildberries, Avito, Lamoda
Big Tech / поисковики — Яндекс, VK, Mail.ru
Телеком — МТС, МегаФон
Стартапы и продуктовые компании
Аутсорс и аутстафф

Зарубежные компании, активно использующие Go:

Cloudflare
Uber
Discord
Twitch
HashiCorp (Terraform, Vault, Consul)
Docker, Kubernetes (CNCF)
Google (родитель языка)
Dropbox, MongoDB, PayPal

Зарплаты по грейдам в РФ/СНГ на 2026 (медианные значения)

Грейд	Средняя ЗП gross (₽/мес)	Диапазон	Опыт
Junior	100 000 – 150 000	80–160 тыс.	0–1.5 года
Middle 1	180 000 – 250 000	150–280 тыс.	1.5–3 года
Middle 2	280 000 – 350 000	230–380 тыс.	3–5 лет
Middle 3	350 000 – 450 000	300–500 тыс.	5+ лет
Senior	450 000 – 600 000+	350–800+ тыс.	6+ лет
Staff/Lead	600 000 – 1 200 000	до 1.5 млн	8+ лет

Медиана по Habr Career на 2026:

Go-разработчик — около 260 000 ₽/мес (на 35% выше среднего по IT-рынку)
Senior Go — около 364 000 ₽/мес

В больших компаниях (Яндекс, Ozon, Т-Банк):

Middle (грейд 13-14 в Яндексе): 320 000 – 450 000 ₽ gross
Senior (грейд 15-16): + RSU составляют значительную часть годового дохода
Cтавки выше рынка на 10-30% за счёт бренда и RSU

Спрос на Go в 2026

Рост — стабильный, умеренный (~15% к 2024 году)
Доля Go-разработчиков: ~3-5% от всех бэкендеров в РФ, но они зарабатывают больше всех в среднем
600+ открытых вакансий на hh.ru одновременно
85% вакансий — удалёнка или гибрид
Дефицит middle-senior уровней — джунов хватает, опытных нет
Тренд 2026: появление в вакансиях обязательной строки “опыт работы с LLM/AI-ассистентами”

2. Грейды и уровни

Junior (0 → Junior)

Опыт: 0–1.5 года коммерческой разработки (или 6–12 месяцев интенсивной самоподготовки + pet-проекты)

Что должен знать:

Базовый Go:

Синтаксис: переменные, типы, операторы, циклы, функции
Структуры данных: array, slice, map, struct
Указатели и ссылочные типы
Интерфейсы — что такое и зачем нужны
Методы и embedding
Обработка ошибок: error, errors.Is, errors.As, fmt.Errorf с %w
defer, panic, recover
Разница между rune и byte, работа с UTF-8 строками
iota и константы

Concurrency на базовом уровне:

Что такое горутины
Каналы (буферизованные/небуферизованные)
select, for range по каналам
sync.WaitGroup, sync.Mutex, sync.RWMutex, sync.Once
Что такое context.Context и четыре конструктора (WithCancel, WithDeadline, WithTimeout, WithValue)
Что такое race condition и как его искать (go run -race)

Стандартная библиотека:

fmt, strings, strconv, bytes
net/http — простой сервер и клиент
encoding/json — marshal/unmarshal
io, os, bufio
time
errors
testing — базовые юнит-тесты с go test
log (или log/slog в Go 1.21+)

Базы данных:

SQL — SELECT, INSERT, UPDATE, DELETE, JOIN
PostgreSQL (в 95-99% случаев в Go — это Postgres)
database/sql + драйвер pgx
Понимание индексов, транзакций
Базовое представление об ORM (GORM, sqlx) — не обязательно использовать

Инструменты:

Git — clone, branch, merge, rebase, conflict resolution
Linux command line — базово
Docker — что такое контейнер, как собрать образ, запустить
Postman / curl — для дёргания API
VS Code или GoLand
Go-модули: go mod init, go get, go mod tidy

Сети и протоколы:

HTTP, REST, JSON
HTTP-методы, статус-коды
Основы TCP/UDP

Какие задачи решает:

Багфиксы по понятным тикетам
Реализация простых CRUD-эндпоинтов
Покрытие кода юнит-тестами
Code review мелких PR старших коллег
Документация
Подготовка простых SQL-запросов

Ответственность: низкая — только за свой код, под контролем

Самостоятельность: низкая — много вопросов, парное программирование

Зона влияния: тикет

Soft skills: умение задавать вопросы, декомпозировать задачу на подзадачи, не бояться спрашивать

Сколько в индустрии: ~25-30% Go-разработчиков (хотя на джунов сложно попасть — рынок зарелся, конкуренция выше)

Средняя ЗП: 100 000 – 150 000 ₽ gross

Middle 1

Опыт: 1.5–3 года

Что должен знать (поверх Junior):

Углублённый Go:

Понимание slice под капотом (header, capacity, growth, slice tricks)
Понимание map под капотом (buckets, hash collisions)
Поведение nil для разных типов
Closure и захват переменных в горутинах (классическая ловушка)
Type assertion, type switch
Empty interface vs any
Generics — базовое применение (min, max, slices, maps)
Кодогенерация — go generate, stringer, mockgen

Concurrency углублённо:

Паттерны: worker pool, fan-out / fan-in, pipeline, generator
Graceful shutdown
sync.Pool — зачем и когда
atomic — когда вместо мьютексов
errgroup (golang.org/x/sync)
Утечки горутин — как находить и предотвращать
Передача отмены через context.Context по цепочке вызовов

Тестирование:

Table-driven tests
Mock’и (gomock, mockery, testify/mock)
Интеграционные тесты с testcontainers
httptest
Бенчмарки (go test -bench=.)
Coverage

Базы данных:

Postgres на хорошем уровне: EXPLAIN, индексы (B-tree, hash, GIN), оконные функции
Транзакции, уровни изоляции
Миграции (golang-migrate, goose, atlas)
Connection pool, pgxpool
ACID, базовое понимание CAP

Архитектура:

Clean Architecture / Hexagonal / Onion — хотя бы один подход
Разделение слоёв: handlers/transport, service/usecase, repository, domain
Dependency Injection (через конструкторы)
Конфигурация (viper, envconfig)

Инфра:

Docker compose
Базовый Kubernetes — pod, deployment, service
CI/CD — GitLab CI, GitHub Actions
Понимание Linter’ов (golangci-lint)
Linux на уровне “разберусь с логами”

Микросервисы / межсервисное взаимодействие:

gRPC + Protocol Buffers (хотя бы один сервис)
Message brokers — Kafka или RabbitMQ (потребитель, продюсер, базово)
Redis — что такое, типы данных, как использовать как кеш
OpenAPI / Swagger

Профилирование:

pprof — CPU и memory profile
Escape analysis (go build -gcflags="-m")

Какие задачи решает:

Самостоятельно делает фичи среднего размера
Декомпозирует задачи
Делает code review
Может работать с легаси
Понимает требования продакта, задаёт уточняющие вопросы
Чинит баги на проде

Ответственность: средняя — за свою фичу, может проводить релиз

Самостоятельность: делает задачи без надзора, но просит помощь по сложным архитектурным вопросам

Зона влияния: фича

Soft skills: коммуникация в команде, отстаивание решений с аргументами, базовый менторинг джунов

Средняя ЗП: 180 000 – 250 000 ₽ gross

Middle 2

Опыт: 3–5 лет

Что должен знать (поверх Middle 1):

Глубинный Go:

GMP-модель планировщика (Goroutine, Machine, Processor) — детально
Local queues, global queue, work stealing
Что происходит при syscall’ах (M отвязывается от P)
Garbage Collector — tricolor mark and sweep, write barriers
Что такое STW (stop-the-world), как минимизировать
Escape analysis на уровне понимания, куда уйдёт переменная
Memory layout структур, alignment, padding
Unsafe package — когда оправдано
Reflection (reflect) — когда нужно, когда нет
Внутреннее устройство interface{} (itab, eface, iface)
Что внутри chan (hchan, buf, sendq/recvq)

Архитектура высоконагруженных систем:

Микросервисы — границы сервисов, DDD
Паттерны: Saga, Outbox, CQRS, Event Sourcing
Circuit Breaker, Retry с экспоненциальной задержкой, Bulkhead
Idempotency — как делать идемпотентные API
Кеширование на нескольких уровнях
Rate limiting и quota’ы
Версионирование API (URL versioning, header versioning)
Service discovery — Consul, etcd

Данные:

Углублённо Postgres — partitioning, репликация, vacuum, MVCC
NoSQL — MongoDB или ScyllaDB (одно знать хорошо)
Поисковые движки — Elasticsearch / OpenSearch
Time-series DB — ClickHouse (актуально в РФ), VictoriaMetrics
Kafka на хорошем уровне — partitions, consumer groups, exactly-once, idempotent producer
ETL pipelines

Observability:

Prometheus + Grafana
Distributed tracing — Jaeger / Tempo, OpenTelemetry
Логирование — структурированные логи (slog, zap, zerolog)
Loki / ELK

Kubernetes:

Helm charts
ConfigMap, Secret
HPA (horizontal pod autoscaler)
ServiceMonitor для Prometheus
Понимание Service Mesh (Istio/Linkerd) на базовом уровне

Безопасность:

OAuth2, JWT
TLS / mTLS
Защита от SQL-инъекций, CSRF, XSS
Secrets management (Vault)

Какие задачи решает:

Дизайн микросервиса целиком
Сложные технические задачи без чёткого решения
Перформанс-оптимизация
Архитектурные обсуждения с лидом
Менторит middle 1 и джунов
On-call дежурства

Ответственность: высокая — за сервис целиком

Самостоятельность: высокая — сам исследует, сам предлагает решения

Зона влияния: сервис

Soft skills: влияние на команду, навык переговоров с продактом, презентация своих решений, технические доклады внутри команды

Средняя ЗП: 280 000 – 350 000 ₽ gross

Middle 3

Опыт: 5+ лет

Что должен знать (поверх Middle 2):

Системное проектирование:

Может спроектировать с нуля сложный сервис, рассчитав нагрузку, выбрав СУБД и протоколы
Понимает trade-off’ы: CAP, BASE, ACID, eventual consistency
Знает, когда выбирать гексагональную архитектуру, когда — монолит, когда — микросервисы
Тонкое понимание распределённых консенсусов — Raft, Paxos (хотя бы Raft)
Распределённые транзакции — 2PC, Saga, TCC
Шардирование, репликация, реплики master-slave / master-master

Перфоманс и оптимизации:

PGO (Profile-Guided Optimization)
Inlining, devirtualization
Управление памятью под GC — sync.Pool, аллокации, escape
Numa-aware вещи, GOGC, GOMAXPROCS, GOMEMLIMIT
HTTP/2, gRPC streaming, server push
Кастомные сериализаторы для горячих путей

Опыт production:

Серьёзные инциденты на проде и их разбор
Capacity planning
Cost optimization (FinOps) — right-sizing в Kubernetes
Migration projects — миграция между БД, языками, между датацентрами
A/B тестирование на инфра-уровне
Feature flags

Лидерские задачи (не путать с менеджментом):

Tech lead для команды 3-5 человек
RFC / Design Doc’и для команды
Code review всех PR в важной части системы
Менторинг middle 2

Стек технологий:

2-3 БД на глубоком уровне
2-3 message broker’а
Kubernetes на уровне самостоятельной настройки
CI/CD — sophisticated пайплайны
Service Mesh, sidecar pattern

Какие задачи решает:

Делает любую задачу в проекте
Рисует system design на whiteboard
Ведёт сложные дискуссии с архитектами
Принимает технические решения для команды
Может временно заменить тимлида
Влияет на найм

Ответственность: очень высокая — за подсистему / несколько сервисов

Самостоятельность: полная

Зона влияния: подсистема / архитектура

Soft skills: ведение технических интервью, фасилитация, конфликт-резолюшен, написание ADR (architecture decision records)

Средняя ЗП: 350 000 – 450 000 ₽ gross + бонусы / RSU в больших компаниях

Senior (потолок, для понимания)

Опыт: 6+ лет коммерческой разработки на Go (или 8+ общего бэкенда с переходом)

Кратко:

Архитектор уровня нескольких сервисов или платформы
Принимает решения, влияющие на всю компанию
Может с нуля построить инфраструктуру
Глубокое понимание internals — не только Go, но и Linux, сети, БД
Tech lead команды 5-10 человек, либо чистый IC (individual contributor) — Staff-уровень
Часто пишет open-source инструменты
Зарплата в РФ: 450 000 – 800 000+ ₽

3. Визуальный roadmap

╔══════════════════════════════════════════════════════════════╗
║                  JUNIOR (0 → 6-12 месяцев)                   ║
╠══════════════════════════════════════════════════════════════╣
║ ├── Базовый Go                                               ║
║ │   ├── Синтаксис, типы, переменные                          ║
║ │   ├── Slice / Map / Struct / Pointer                       ║
║ │   ├── Функции, методы, интерфейсы                          ║
║ │   ├── Error handling (errors.Is, errors.As, %w)            ║
║ │   ├── defer / panic / recover                              ║
║ │   └── Rune vs Byte, UTF-8                                  ║
║ ├── Concurrency (базово)                                     ║
║ │   ├── Goroutines                                           ║
║ │   ├── Каналы + select                                      ║
║ │   ├── sync.WaitGroup, sync.Mutex                           ║
║ │   ├── context.Context (4 конструктора)                     ║
║ │   └── -race detector                                       ║
║ ├── Стандартная библиотека                                   ║
║ │   ├── net/http (сервер + клиент)                           ║
║ │   ├── encoding/json                                        ║
║ │   ├── time, io, os, bufio                                  ║
║ │   └── testing                                              ║
║ ├── Базы данных                                              ║
║ │   ├── SQL основы (Postgres)                                ║
║ │   ├── database/sql + pgx                                   ║
║ │   └── CRUD                                                 ║
║ ├── Инструменты                                              ║
║ │   ├── Git (clone/branch/merge/rebase)                      ║
║ │   ├── Docker (запустить контейнер)                         ║
║ │   ├── Linux CLI (базово)                                   ║
║ │   └── VS Code / GoLand                                     ║
║ └── Pet-проекты (1-2 штуки)                                  ║
║     ├── REST API на net/http                                 ║
║     └── Telegram-бот или CLI-утилита                         ║
╚══════════════════════════════════════════════════════════════╝
                              ↓
╔══════════════════════════════════════════════════════════════╗
║              MIDDLE 1 (1.5 → 3 года)                         ║
╠══════════════════════════════════════════════════════════════╣
║ ├── Углублённый Go                                           ║
║ │   ├── Slice под капотом (cap, growth)                      ║
║ │   ├── Map под капотом (buckets)                            ║
║ │   ├── Generics (slices, maps, новые функции 1.21+)         ║
║ │   ├── Reflect (базово)                                     ║
║ │   └── Кодогенерация                                        ║
║ ├── Concurrency (паттерны)                                   ║
║ │   ├── Worker pool                                          ║
║ │   ├── Fan-out / Fan-in                                     ║
║ │   ├── Pipeline                                             ║
║ │   ├── Graceful shutdown                                    ║
║ │   ├── sync.Pool, atomic                                    ║
║ │   ├── errgroup                                             ║
║ │   └── Goroutine leak detection                             ║
║ ├── Тестирование                                             ║
║ │   ├── Table-driven tests                                   ║
║ │   ├── Mock (gomock, mockery)                               ║
║ │   ├── httptest                                             ║
║ │   ├── Бенчмарки                                            ║
║ │   └── Coverage                                             ║
║ ├── Архитектура                                              ║
║ │   ├── Clean Architecture / Hexagonal                       ║
║ │   ├── DI через конструкторы                                ║
║ │   └── Слои handlers/service/repo                           ║
║ ├── Postgres (углублённо)                                    ║
║ │   ├── EXPLAIN, индексы                                     ║
║ │   ├── Транзакции и изоляции                                ║
║ │   ├── Миграции (golang-migrate)                            ║
║ │   └── Pool / pgxpool                                       ║
║ ├── Микросервисы (базово)                                    ║
║ │   ├── gRPC + Protobuf                                      ║
║ │   ├── Kafka / RabbitMQ (consumer/producer)                 ║
║ │   ├── Redis (кеш)                                          ║
║ │   └── OpenAPI                                              ║
║ └── Профилирование                                           ║
║     ├── pprof (CPU, memory)                                  ║
║     └── Escape analysis (-gcflags=-m)                        ║
╚══════════════════════════════════════════════════════════════╝
                              ↓
╔══════════════════════════════════════════════════════════════╗
║              MIDDLE 2 (3 → 5 лет)                            ║
╠══════════════════════════════════════════════════════════════╣
║ ├── Глубинный Go                                             ║
║ │   ├── GMP-модель (G, M, P, work stealing)                  ║
║ │   ├── Syscalls и поведение планировщика                    ║
║ │   ├── GC: tricolor mark+sweep, STW, write barrier          ║
║ │   ├── Memory layout, alignment, padding                    ║
║ │   ├── unsafe, reflect (продвинутый)                        ║
║ │   ├── Interface internals (itab, eface, iface)             ║
║ │   └── chan internals (hchan)                               ║
║ ├── Архитектура HighLoad                                     ║
║ │   ├── Saga, Outbox, CQRS, Event Sourcing                   ║
║ │   ├── Circuit Breaker, Retry, Bulkhead                     ║
║ │   ├── Idempotency, dedup                                   ║
║ │   ├── Многоуровневое кеширование                           ║
║ │   ├── Rate limiting (token bucket, leaky bucket)           ║
║ │   └── API versioning                                       ║
║ ├── Данные                                                   ║
║ │   ├── Postgres: partitioning, репликация, MVCC, vacuum     ║
║ │   ├── NoSQL: MongoDB или ScyllaDB                          ║
║ │   ├── ClickHouse / VictoriaMetrics                         ║
║ │   ├── Elasticsearch                                        ║
║ │   └── Kafka: exactly-once, idempotent producer             ║
║ ├── Observability                                            ║
║ │   ├── Prometheus + Grafana                                 ║
║ │   ├── Jaeger / OpenTelemetry                               ║
║ │   ├── Structured logs (slog, zap)                          ║
║ │   └── Loki / ELK                                           ║
║ ├── Kubernetes                                               ║
║ │   ├── Helm                                                 ║
║ │   ├── HPA                                                  ║
║ │   ├── ServiceMonitor                                       ║
║ │   └── Service Mesh (Istio/Linkerd) — базово                ║
║ └── Безопасность                                             ║
║     ├── OAuth2, JWT                                          ║
║     ├── TLS, mTLS                                            ║
║     └── Vault                                                ║
╚══════════════════════════════════════════════════════════════╝
                              ↓
╔══════════════════════════════════════════════════════════════╗
║              MIDDLE 3 (5+ лет)                               ║
╠══════════════════════════════════════════════════════════════╣
║ ├── System design                                            ║
║ │   ├── Полный дизайн сложного сервиса                       ║
║ │   ├── CAP / BASE / eventual consistency                    ║
║ │   ├── Raft (хотя бы концепция)                             ║
║ │   ├── 2PC / Saga / TCC                                     ║
║ │   └── Шардирование и репликация на практике                ║
║ ├── Performance                                              ║
║ │   ├── PGO (Profile-Guided Optimization)                    ║
║ │   ├── Inlining, devirtualization                           ║
║ │   ├── GOGC, GOMAXPROCS, GOMEMLIMIT                         ║
║ │   ├── HTTP/2, gRPC streaming                               ║
║ │   └── Кастомные сериализаторы                              ║
║ ├── Production experience                                    ║
║ │   ├── Опыт реальных инцидентов и postmortem'ов             ║
║ │   ├── Capacity planning                                    ║
║ │   ├── FinOps / Right-sizing                                ║
║ │   ├── Migration projects                                   ║
║ │   └── Feature flags                                        ║
║ └── Tech leadership                                          ║
║     ├── Tech lead команды 3-5 человек                        ║
║     ├── RFC / Design Doc / ADR                               ║
║     ├── Менторинг middle 2                                   ║
║     └── Влияние на найм                                      ║
╚══════════════════════════════════════════════════════════════╝
                              ↓
                ┌──────────────────────────┐
                │   SENIOR (6+ лет)        │
                │   Архитектор / Staff IC  │
                └──────────────────────────┘

4. Сроки и ожидания

Переход	Реалистичный срок	Условия
0 → Junior	6–12 месяцев	Самообучение 2-3 ч/день + 2 pet-проекта
0 → Junior (курсы)	4–9 месяцев	Платный курс + домашки + ментор
Junior → Middle 1	1.5–2 года	Работа в команде, реальные задачи
Middle 1 → Middle 2	1.5–2 года	Опыт нескольких сервисов, на проде
Middle 2 → Middle 3	1.5–3 года	Большая ответственность, ведение проектов
Middle 3 → Senior	2–4 года	Tech lead-опыт, system design на практике

Общий путь 0 → Middle 3: ~6–10 лет

Ускорители:

Работа в продуктовой команде (Яндекс, Авито, Ozon, Т-Банк) — растёшь быстрее
Регулярные code review старших коллег
Менторство сверху и снизу
Чтение книг, статей, докладов
Конференции (GopherCon Russia, GolangConf)
Open-source контрибуции

Замедлители:

Работа на лёгком стеке без нагрузки
Отсутствие старших коллег
Перепрыгивание через грейды (бывает, что middle 1 уже сидит на сеньорской позиции, потом тяжело)
Отсутствие обратной связи

5. Альтернативные пути

A. Backend с другого языка (Java, Python, Node.js, C#, PHP) → Go

Сроки сокращаются в 2-3 раза. За 3-6 месяцев можно выйти на уверенный middle 1 / middle 2 по Go при наличии опыта.

Что нужно сделать:

Прочитать “The Go Programming Language” (Donovan, Kernighan) — за 2-4 недели плотного чтения
Пройти Tour of Go (бесплатно, на go.dev) — за выходные
Прочитать “100 Go Mistakes” (Teiva Harsanyi) — на этой книге впитываются “правильные” Go-подходы
Сделать боевой проект на Go — желательно похожий на то, что делал на старом языке
Изучить concurrency-паттерны Go — это самое непривычное для пришедшего из других языков
Понять, что Go — не Java — не пихать туда DI-контейнеры, аннотации, не плодить абстракции
Принять простоту Go — там нет наследования, нет исключений, нет дженериков как в C++

Типичные ошибки переходящих:

Java-разработчики делают слишком много интерфейсов “на всякий случай”
Python-разработчики не привыкли к статической типизации, забывают про ошибки
C#-разработчики ищут LINQ
Все ищут “своих” frameworks — а в Go стандартная библиотека сама по себе мощная

Где брать опыт: Ozon, Avito и Т-Банк имеют программы перехода Backend → Go (3 месяца).

B. Студент с нуля → Junior Go

Сроки: 8–14 месяцев интенсивной подготовки.

Маршрут:

Месяц 1-2: Базовый синтаксис, типы, функции, простые программы. Bookс “Go в действии” или Stepik-курсы.
Месяц 3: Concurrency на базовом уровне. Каналы, горутины, mutex.
Месяц 4-5: SQL + Postgres. Простые CRUD-сервисы.
Месяц 6: HTTP-сервер + REST API + Docker. Первый pet-проект (URL-shortener, todo-list, заметки).
Месяц 7-8: Углубление: pprof, бенчмарки, тестирование, gRPC, Redis. Второй pet-проект (что-нибудь с concurrency — например, web scraper или метрик-collector).
Месяц 9-10: Подготовка к собесам — алгоритмы, типовые вопросы, mock interviews.
Месяц 11-12: Поиск работы. Параллельно — третий проект и/или вклад в open source.

Совет: искать стажировки уже на 6-7 месяце (Т-Банк, Ozon, Яндекс, Сбер постоянно набирают стажёров).

C. С DevOps / SRE → Go

Многие SRE и DevOps пишут на Python/Bash и хотят перейти на Go (так как все инструменты CNCF — на Go). Это быстрый путь:

Уже знают Linux, Docker, K8s
Уже работают с Prometheus / Grafana
Просто нужно подтянуть язык

Срок: 3-5 месяцев до middle 1.

6. Ключевые ошибки в обучении

Ошибки, которые делают новички

Слишком ранний deep dive в internals Изучать GMP-модель и GC на старте — пустая трата времени. Нужны основы, типы, базовая concurrency.
Перепрыгивание уровней Прыжок Junior → Middle 2 без middle 1 — это годы технических долгов в голове. Лучше быть крепким middle 1, чем шатким middle 2.
Отсутствие реальных проектов Туториалы — не опыт. Если у вас нет хотя бы одного “взрослого” проекта (с БД, тестами, Docker, CI), вы не дойдёте даже до собеса.
Изучение всего сразу Многие новички совершают ошибку, пытаясь изучить все технологии одновременно. Лучше: Go → Postgres → Docker → HTTP API → тесты → потом всё остальное.
Игнорирование тестов В Go тесты — часть культуры. Не уметь писать тесты — сигнал работодателю “не зрелый”.
Копирование туториалов без понимания Если вы не можете объяснить, почему написали именно так — вы не научились.
Без code review Решение: контрибуции в open source, прохождение реального стажа, мок-ревью с ментором.
Изучение только синтаксиса, без бэкенда Знать Go без знания HTTP, SQL, Docker — это знать алфавит без слов.
Откладывание собеседований “пока не выучу всё” Никогда не выучите всё. Идти на собес — лучший способ понять, что вы не знаете. Первые 5-10 отказов — это норма.
Слишком много книг, мало практики Соотношение должно быть: 30% теория, 70% написание кода своими руками.
Не использовать go vet и линтеры В реальной разработке без golangci-lint ваш код будут заворачивать на ревью.
Игнорирование Go idioms “Я пишу Go как Python/Java/C++” — типичная фраза тех, кто валит собес. Go имеет свои идиомы:
- Маленькие интерфейсы
- Возврат ошибок, а не throw
- Composition over inheritance
- Простота важнее умничанья

Roadmap Go-разработчика 2025-2026: от 0 до Middle 3

1. Введение

Кто такой Go-разработчик в 2026

Где работают Go-разработчики

Зарплаты по грейдам в РФ/СНГ на 2026 (медианные значения)

Спрос на Go в 2026

2. Грейды и уровни

Junior (0 → Junior)

Middle 1

Middle 2

Middle 3

Senior (потолок, для понимания)

3. Визуальный roadmap

4. Сроки и ожидания

5. Альтернативные пути

A. Backend с другого языка (Java, Python, Node.js, C#, PHP) → Go

B. Студент с нуля → Junior Go

C. С DevOps / SRE → Go

6. Ключевые ошибки в обучении

Ошибки, которые делают новички

Источники