Go Developer Resume
Skills & ATS Keywords

The foundation. Name the language version outright (Go 1.22 or 1.23) and show you write idiomatic Go: generics where they earned their seat, small interfaces, value-vs-pointer instincts, error handling with errors.Is and errors.As, context propagation, slices and maps internals, build tags, and Go modules. struct tags read as the line between someone who has shipped Go and someone who transcribed a tutorial.

Go 1.23, generics, interfaces, error handling, context, slices and maps internals, struct tags, build tags, modules

Where most of the senior signal lives on a Go resume. Goroutines and channels are the baseline; the differentiator is which patterns you actually shipped, select over fan-in fan-out, sync primitives where channels do not fit, errgroup for bounded pipelines, semaphores, the race detector turned on in CI, and context-driven cancellation that does not leak.

goroutines, channels, select, sync primitives, errgroup, semaphores, race detector, context-driven cancellation

The stdlib-first habit that separates a Go file from a polyglot back-end one. net/http for the HTTP layer (1.22 routing pulled a lot of work back into the stdlib), encoding/json with json.Decoder on streams, database/sql with prepared statements, io with proper reader and writer composition, os, time, testing, sort. If you reach for a framework before the stdlib without a reason, it shows.

net/http, encoding/json, database/sql, io, os, time, testing, sort, stdlib-first philosophy

The contract the rest of the org talks to. net/http handlers and chi cover most production Go; gin or echo show up on teams that wanted a richer router. gRPC is the differentiator past mid level, paired with grpc-gateway for the REST edge, OpenAPI codegen for the doc story, and gqlgen or WebSockets when the product asked for it.

net/http handlers, chi, gin, echo, gRPC, grpc-gateway, OpenAPI codegen, GraphQL (gqlgen), WebSockets

How your service holds and queries state. pgx is the modern default for PostgreSQL on a Go service; sqlx and sqlc each have a clear seat (sqlc when you want generated, type-safe queries). GORM still ships on a slice of teams. Add Redis, S3, BoltDB on small embedded work, and the messaging shape you actually used.

pgx, sqlx, sqlc, GORM, Ent, Redis, S3, BoltDB, NATS JetStream, Kafka via segmentio/kafka-go

Name your test stack and the quality gate. go test with table-driven tests is the baseline; fuzzing on parsers, benchstat to compare bench runs, the race detector turned on in CI, plus golangci-lint, staticcheck, gofumpt, and govulncheck for the supply-chain story. mod graph reads as someone who actually owns the dependency tree.

go test, table tests, fuzzing, benchstat, race detector, golangci-lint, staticcheck, gofumpt, govulncheck, go mod graph

How the binary runs in production. Docker on a scratch or distroless base, Kubernetes on the cluster, controller-runtime and kubebuilder when you owned an operator, Helm for the chart story. On the observability side OpenTelemetry-Go traces, pprof for the allocation walk, expvar for the cheap metrics, Prometheus on the dashboard. Cobra and Viper turn up wherever there is a CLI to ship.

Docker, Kubernetes, controller-runtime, Helm, OpenTelemetry-Go, pprof, expvar, Prometheus, Cobra, Viper

The vocabulary that lifts a Go coder to a designer. Idiomatic Go (small interfaces, accept interfaces, return structs), DDD-light, hexagonal where the team needed boundaries, channels as pipelines, and the cmd plus internal layout that keeps the tree readable. Skip the DI framework talk; Go services compose explicitly.

idiomatic Go (small interfaces, accept interfaces return structs), DDD-light, hexagonal, channels-as-pipelines, cmd/internal layout