Building The Go Engineer: Teaching Go as a Software Engineering Discipline

The Go Engineer project treats a GitHub repository as both textbook and testbed for learning backend engineering in Go. It moves beyond syntax drills to ask learners how language features behave inside a system with boundaries, failures, and operational concerns.

The curriculum is organized as a locked architecture with a machine‑readable registry, runnable lessons, and a validator that checks consistency between code, documentation, and tests. This structure ensures that the material stays aligned as the project evolves.

At the heart of the repository is Opslane, a production‑shaped backend that ties together configuration, PostgreSQL, authentication, tenant isolation, migrations, workers, observability, rate limiting, and graceful shutdown. Opslane is not a toy example; it is designed to reflect the concerns of a real service.

The folder layout makes ownership explicit: cmd/server starts the program, internal/auth handles credentials, internal/db manages persistence, and internal/workers runs background tasks. When someone opens the project they can quickly see where each responsibility lives.

Dependencies are assembled in one visible place so learners can ask who owns each resource, and tenant scope is baked into models, repositories, handlers, and services rather than added later. This teaches that security and tenancy are architectural concerns.

Migrations are treated as first‑class SQL files with startup checks to detect drift; metrics and tracing are wired into the HTTP stack; rate limiting uses a PostgreSQL‑backed counter that works across instances; and a shutdown coordinator drains workers, cancels contexts, and releases resources before exit.

The CI pipeline runs builds, vet, format, tidy, tests, race detection, vulnerability scanning, coverage thresholds, curriculum validation, and Docker builds, teaching that release quality requires more than just compiling code.

A custom validator checks that lesson paths, README links, and migration documentation stay in sync, while a KNOWN_LIMITATIONS.md file marks where teaching stubs diverge from production‑ready libraries.

The project is source‑available for personal and educational use; commercial use needs permission. Release‑quality here means the architecture is locked, the registry validated, lessons runnable, documentation structured, Opslane integrates real backend concerns, limitations are documented, and CI provides strong evidence of correctness.

By treating the repository itself as the curriculum, The Go Engineer shows that engineering discipline emerges from the shape of the code, the tests, the documentation, and the automation that surrounds it.

Learners can clone the repository, run go mod tidy, execute the provided makefile, and watch the validator flag any drift as they edit lessons or Opslane code. This tight feedback loop reinforces the idea that a healthy project protects its own claims automatically.