Go / Golang: mercado

Vacante

un empleo abierto que superó el filtro de calidad y menciona al menos dos tecnologías

Candidato observado

un candidato cuyo stack contiene esta tecnología; es un agregado: ni un solo registro sale del perímetro

Candidato emparejable

aún no contabilizado

Ventana

empleos abiertos en el momento en que se generó el snapshot

Las vacantes Junior de Go son muy raras: el mercado espera experiencia Backend Middle+ en Python/Java/Node + un proyecto personal en Go listo. El mayor salto salarial está entre Junior y Middle (dominio de la concurrencia: goroutines, canales, sync, context). Un Senior es responsable de la arquitectura del servicio. Lead: responsable de un dominio (p. ej., pagos en Tinkoff) con 3-7 ingenieros de Go. Trayectoria: Backend Middle (Python/Java/Node) → Go Middle tras una transición de 6-12 meses → Senior → Lead / Staff / Go Infrastructure.

Tecnologías principales 5: go, golang, cloud, kubernetes, ci/cd. Go 1.21+ obligatorio (generics, logging estructurado slog). Web: chi (ligero moderno), gin/echo/fiber (completos), net/http de la stdlib (la vía purista; tras el router mejorado de Go 1.22, una opción viable). gRPC + Protocol Buffers, obligatorio para microservicios. PostgreSQL + pgx (el driver de la industria) / sqlc (codegen desde SQL). Kafka (kafka-go / franz-go). Redis (go-redis). Docker + Kubernetes, Go es el lenguaje nativo de k8s. Prometheus + OpenTelemetry Go SDK, estándar de oro. testify + gomock + testcontainers-go para testing. Primitivas de concurrencia (ciclo de vida de goroutines, patrones de channels, sync.Mutex/RWMutex, context.Context), obligatorio para Senior. Profiling vía pprof, un plus.

Go gana en: (1) APIs de alta carga con baja latencia (5-20× más rápido que Python, un 30-50% más rápido que Java en cargas intensivas de E/S). (2) microservicios en k8s: arranque rápido (<100ms), poca memoria (10-50 MB frente a 200–500 MB de la JVM). (3) herramientas cloud-native: k8s/Docker/Terraform/el stack de HashiCorp están todos escritos en Go. (4) cargas con mucha concurrencia: las goroutines son más baratas que los hilos. Python: ML/IA/datos, prototipado rápido. Java: software empresarial/bancario, ecosistema Spring Boot, un gran mercado junior. Estrategia de carrera: Python Senior + Go = el perfil ideal para alta carga + ML. Java Senior + Go: una síntesis de cloud-native + empresa.

chi — router moderno y ligero (~1.500 LoC), Go idiomático, tendencia en alza 2025–2026. Elección premium para proyectos nuevos. Gin — el más popular en la CEI (60%+ de los empleos de producto), ecosistema maduro, binding de JSON de serie. Echo — un análogo cercano a Gin, con DX algo mejor. Fiber — inspirado en Express.js, muy rápido (construido sobre fasthttp), pero no es Go idiomático. De nicho. net/http stdlib — tras Go 1.22 el router mejorado (patrones de ruta + method matching) hace viable la stdlib. La tribu purista lo recomienda. Estrategia: net/http + chi primero (idioma), luego Gin (mercado), Echo/Fiber según haga falta. Junior — empieza con Gin (los mejores tutoriales).

Sí, el 37% de los empleos de Go son full-remote o híbridos. Go domina lo cloud-native — el trabajo es cloud. El SaaS cloud-native — full-remote. Los bancos rusos (Sber/Alfa) — híbrido. Hubs de relocación: Dubái, Chipre, Berlín, Ámsterdam, Varsovia, Tiflis. El inglés abre el mercado cloud-native global (prima +25-40%). Go es el lenguaje de backend más European-friendly de 2026 (Exoscale/Scaleway/OVH contratan activamente ingenieros Go).

Go Backend escribe el backend de PRODUCTO en Go: APIs REST/gRPC, lógica de negocio, bases de datos transaccionales. DevOps escribe INFRAESTRUCTURA: Terraform/Pulumi, Ansible, manifiestos de k8s/Helm, CI/CD. Menos programación, más YAML/HCL/Bash. Go Infrastructure Engineer (híbrido): escribe operadores de k8s, controladores propios, herramientas de infraestructura en Go. Programación = Senior Go completo + sistemas distribuidos. Senior Go Backend ≈ Senior DevOps en Moscú; Go Infrastructure Engineer = +15-25% (combinación poco común). Cambio de carrera de Go Backend a Go Infrastructure en 6-12 meses. De DevOps a Go Backend es raro: exige dominar la programación hasta Middle+.

Se supone experiencia Backend Middle+ (Python/Java/Node). Hoja de ruta: 1) Sintaxis de Go: "A Tour of Go" + "The Go Programming Language" (Donovan/Kernighan). 2) Concurrencia: goroutines, canales, select, sync, context.Context. "Concurrency in Go" de Cox-Buday. 3) Stdlib: net/http, encoding/json, database/sql, log/slog. No te lances a los frameworks con prisas. 4) Un framework web: chi (idiomático) o Gin (el del mercado). 5) PostgreSQL + pgx: servicio personal con base de datos + transacciones. 6) gRPC + Protocol Buffers: 2 microservicios. 7) Nociones de Kafka (kafka-go / franz-go). 8) Docker + nociones de k8s (minikube/k3d). 9) Pruebas: testify + gomock + testcontainers-go. 10) Proyecto personal de extremo a extremo: 2-3 microservicios (gRPC + gateway REST) + Kafka + PostgreSQL + Redis + Prometheus + Grafana + CI con GitHub Actions. Cursos: Karpov.Courses "Go Developer", Yandex.Practicum "Backend on Go". Libro: "100 Go Mistakes" de Harsanyi. Backend Middle → Go Middle: 6-12 meses.

519 active open Go Backend positions in the Zorky sample. One of the fastest-growing backend segments of 2024–2026. Geography: the US, Russia, Poland. Sources: hh.ru, Habr Career, getmatch (large Go segment), Djinni, NoFluffJobs/JustJoin.it (Poland — huge demand for Go Senior remote for Russian-speakers), LinkedIn (international cloud-native), Telegram, GoLang.org Jobs, Reddit r/golang. Time-to-close for Senior Go — 3-6 weeks.

Un Senior Go Backend es responsable del ciclo completo. Núcleo de Go: dominio de la concurrencia (ciclo de vida de las goroutines, patrones de canales fan-in/fan-out/workers, select, propagación de la cancelación con context.Context), genéricos, patrones de manejo de errores (wrapping/sentinel/typed), reglas de satisfacción de interfaces, escape analysis. Arquitectura: microservicios sobre gRPC + Protocol Buffers, event-driven con Kafka, idempotencia + locks distribuidos, patrón saga. Rendimiento: profiling con pprof (CPU/memoria/goroutines), ajuste del GC (GOGC/GOMEMLIMIT), benchmarking con testing.B. PostgreSQL: SQL avanzado, tablas particionadas, connection pooling con pgx. Kubernetes: escribir controllers/operators personalizados en Go (controller-runtime), comprensión más profunda de la API de k8s. Observabilidad: logging estructurado (slog), diseño de métricas de Prometheus, trazas distribuidas con OpenTelemetry. Pruebas: table-driven, gomock, testcontainers-go. Soft: code review, mentoría, diseño junto al PM. Inglés para Senior+ imprescindible, la comunidad de Go es mayoritariamente angloparlante.