Welcome: How to Use This Course

Who This Course Is For

You've finished the fundamentals of Go — variables, functions, structs, interfaces, goroutines, the standard library — and you can write small programs that work. What you haven't done yet is build a backend system that a real team could run in production: one with a database, authentication, multiple services talking to each other, tests, containers, and a deployment pipeline. That gap is exactly what this course exists to close.

What You Should Already Know

• Core Go syntax: variables, structs, methods, interfaces, error handling, goroutines and channels at a basic level.
• How to read and write to the terminal, and how to run go run / go build / go test.
• Basic Git: clone, branch, commit, push — you will not need advanced Git workflows.
• Basic SQL: SELECT, INSERT, UPDATE, JOIN. Chapter 3 teaches multi-tenant schema design assuming you know ordinary single-table SQL already.

You do not need to already know: HTTP routing frameworks, JWTs, Redis, Kafka, Docker, or Kubernetes. Every one of these is introduced from scratch in the chapter where it first becomes necessary — never earlier, and never assumed.

What You'll Need Installed

• Go 1.26 or later — go version should print 1.26.x.
• Docker (or a compatible container runtime) — used from Chapter 3 onward to run Postgres locally, and again in the containerization chapters.
• A terminal and a code editor with Go language support (VS Code with the Go extension, or GoLand).
• Postman or an equivalent HTTP client — introduced in the testing chapter for exercising the API by hand.

Nothing else is required up front. Redis, Kafka, and Kubernetes tooling are each introduced with their own setup instructions in the chapter that needs them, following the same grow-as-you-go principle the codebase itself follows: nothing is installed or scaffolded before a lesson gives you a concrete reason to need it.

What This Course Documents

This course documents Meridian, an in-progress Go microservices project implementing a multi-tenant HOA (homeowners association) management platform. The project is organized as five Go modules under a single go.work workspace: apps/gateway, apps/identity-service, apps/community-service, apps/billing-service, and libs/platform, a shared library used by all four services.

Chapters follow the repository's actual structure, not a reordering optimized for narrative effect. Where a chapter covers functionality not yet implemented, the text states this explicitly and grounds the description in the Platform Contract types that already exist, rather than presenting invented code as working.

How to Read Each Lesson

• Every lesson opens with the concept in isolation — what problem it solves and why it exists — before it touches Meridian's code at all.
• Code excerpts are labeled with their real file path (e.g. apps/identity-service/internal/domain/domain.go) so you always know where a snippet would live in the project.
• A callout marked "design specification" means the feature is not implemented yet — you are reading the reasoning and the intended shape, not a finished implementation. Treat these as the exercise: implement it yourself after reading the lesson.
• Each chapter's final lesson closes with "The Decision" or an equivalent summary block — read that first if you want the conclusion before the reasoning.

Your Learning Path

The 20 chapters are grouped into four stages. Work through them in order — each stage assumes everything in the stages before it.

• Stage 1 — Foundations (Chapters 1–2): the domain you're building, the tech stack, the multi-module workspace, and the interfaces/dependency-injection style used everywhere after this point.
• Stage 2 — The Core Service (Chapters 3–7): schema design, the identity-service HTTP layer, authentication and RBAC, the API gateway, and how to test all of it.
• Stage 3 — Cross-Cutting Concerns (Chapters 8–15): caching, background jobs, file storage, events, resilience, observability, and advanced Postgres — the concerns every mature service needs regardless of what it does.
• Stage 4 — Shipping It (Chapters 16–20): API versioning, containerization, CI/CD, security hardening, and a capstone that wires every service together end to end, closing with a retrospective on what changed from the original plan.

Scope Boundaries

• In scope: Go workspace structure, multi-tenant Postgres design, service boundaries, the gateway pattern, authentication and RBAC, caching, background processing, event-driven communication, observability, containerization, deployment, and CI/CD.
• Out of scope: introductory Go syntax and stdlib basics, general HTTP fundamentals, and frontend implementation (meridian-web is a separate repository acting as a BFF and is referenced only where it affects the API contract).
• Not covered: fabricated implementation detail for chapters describing planned work. Where code does not yet exist, the chapter states the design and the reasoning behind it, and nothing more.