Team Onboarding Basics

9 examples to get you started with Team & Onboarding - 7 basic and 2 intermediate.

Prerequisites

• Install Go 1.26.x or later from go.dev/dl.
• Clone your team repository and confirm go version matches the version in CI (check .github/workflows or Makefile).
• Install golangci-lint if your repo documents it; verify the version against team standards.
• Have SSH or HTTPS credentials for GitHub (or your forge) and access to the team Slack or chat channel.

Basic Examples

1. Verify toolchain and module

Confirm Go and module metadata before touching application code.

// Run in repo root after clone:
// go version
// go mod download
// go env GOMOD GOPATH

go version
go mod download
go env GOMOD

• go mod download fetches modules listed in go.mod without building.
• GOMOD shows the active module file path; empty means you are outside a module.
• CI often pins a Go image tag - match it locally to avoid "works on my machine" drift.

Related: Onboarding Go Specialists - ramp paths for experienced hires

2. Run the full local test suite

Green tests are the baseline proof that your laptop matches the team environment.

go test ./...

• ./... recurses all packages under the current module.
• Add -race when your team requires it for concurrency packages.
• A failure on clone usually means missing env vars documented in README.

Related: Go SME Onboarding Checklist (30/60/90) - day-30 test expectations

3. Format and vet before first commit

Automate what reviewers will ask for anyway.

gofmt -w .
go vet ./...

• gofmt is the only official formatter; unformatted code should not merge.
• go vet flags suspicious constructs; many teams run it in CI.
• Pair with golangci-lint run when the repo ships a .golangci.yml.

Related: Code Review Culture for Go - what reviewers expect on every PR

4. Find package entry and main

Learn where binaries start and how packages connect.

go list -f '{{.ImportPath}}' ./...
grep -r "func main" cmd/ 2>/dev/null || grep -r "func main" .

• Most services use cmd/<binary>/main.go layout.
• go list shows import paths your module owns.
• Knowing main location helps you trace wiring on day one.

Related: Effective Go Reading Path - study order after repo orientation

5. Read package docs locally

Preview godoc the way reviewers expect exported APIs to read.

go doc ./internal/config
go doc -all ./...

• Comments on exported symbols should start with the symbol name.
• go doc is faster than spelunking files when exploring unfamiliar packages.
• Note packages missing docs; improving them is a good first PR.

Related: Documentation & godoc Conventions - team comment standards

6. Run CI-equivalent Make or script target

Reproduce pipeline steps locally before pushing.

make test
# or
./scripts/ci.sh

• Teams wrap go test, lint, and build behind make for consistency.
• Read the Makefile or workflow YAML to see flags CI adds (race, coverage thresholds).
• Fixing a red CI step locally saves review round-trips.

Related: Onboarding Go Specialists - why CI parity matters in week one

7. Open a small first PR

Merge something low-risk to learn the review workflow.

Typical first PRs: fix a typo in README, add a missing godoc sentence, or extend a table-driven test.

git checkout -b onboarding/first-pr
# edit files
go test ./...
git commit -m "docs: clarify local setup steps"
git push -u origin HEAD

• Keep scope tiny so feedback focuses on process, not architecture.
• Respond to review comments with commits or explained trade-offs.
• Link the PR in your 30/60/90 checklist when merged.

Related: Pairing & Mob Sessions for Go Teams - optional pairing before first push

Intermediate Examples

8. Trace a handler with context and errors

Follow one request path to see idiomatic error and context usage in your codebase.

func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    if err := s.db.Ping(ctx); err != nil {
        http.Error(w, "unavailable", http.StatusServiceUnavailable)
        return
    }
    w.WriteHeader(http.StatusOK)
}

• r.Context() carries deadlines and cancellation from the server.
• Handlers map errors to HTTP status at the edge; libraries return error.
• Grep for similar handlers to learn naming and middleware patterns.

Related: Effective Go Reading Path - concurrency and HTTP sections next

9. Schedule a pairing session with agenda

Structured pairing beats ad-hoc screen sharing for week-one learning.

Agenda template:

1. Walk module layout and cmd/ binaries (15 min).
2. Live review of an exemplar merged PR (20 min).
3. Pair on a -race test run or linter fix (25 min).

• Record notes in the team wiki or onboarding ticket.
• Rotate buddies monthly so you absorb multiple review voices.
• Bring one concrete question (errors, interfaces, or testing) to each session.

Related: Pairing & Mob Sessions for Go Teams - mob formats and concurrency drills

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).