# Mission: gRPC

## Why
Walk into a gRPC interview able to explain *how gRPC works and why it's designed that
way* — from the proto contract down to HTTP/2 framing — with a mental model solid enough
to reason about questions I've never seen. I write gRPC handlers in this monorepo but the
plumbing is largely scaffolded for me, so the model (streaming, interceptors, status,
deadlines, metadata) isn't yet second nature. Every concept is anchored to real gRPC code
in my team's services — **conversationmgmt**, **notification** (`internal/notification`),
and **spike** (`internal/spike`) — so an abstract idea lands on code I already touch.

## Success looks like
- I can explain what gRPC is, why it uses Protocol Buffers + HTTP/2, and how it differs
  from REST — and when I'd choose each.
- I can read/write a `.proto` (messages, field numbers, services) and describe how `buf`
  generates the Go client and server stubs.
- I can explain all four RPC types (unary, server-streaming, client-streaming,
  bidirectional) and pick the right one for a given problem.
- I can trace a request through the interceptor chain (auth, logging, tracing, recovery)
  and explain what an interceptor is and why.
- I can reason about the status-code error model, context deadlines & cancellation, and
  metadata (headers) flowing in and out — and how RBAC claims reach a handler.
- I can answer the classic gRPC interview questions (why HTTP/2, proto field numbers,
  deadlines vs timeouts, unary vs streaming, load balancing) without hand-waving.

## Constraints
- **Newer to gRPC** — I've mostly worked at the REST/HTTP level and in domain logic;
  lessons don't assume the gRPC model is internalised, but can assume general backend and
  Go maturity (I've done the [Go course](../golang/index.html)).
- **Format:** interactive HTML lessons (recall quizzes) + dense Markdown references —
  same format as the [Kafka](../kafka/index.html) & [Go](../golang/index.html) courses.
  Lives in `docs/grpc/`.
- **Multi-session:** the roadmap ([index.html](./index.html)) spans five parts; lessons
  are short and arrive part by part.
- **All four pillars in scope:** Protobuf & the 4 RPC types · interceptors & middleware ·
  errors/status/deadlines/metadata · architecture (streaming, auth, load balancing, REST).

## Out of scope (for now)
- Non-Go gRPC (Java/Python/C++ specifics) beyond conceptual parallels.
- Deep HTTP/2 internals (HPACK, flow-control windows) beyond "why gRPC picked it".
- gRPC-Web / browser clients, unless the mission shifts.
- (Revisit if the mission changes — confirm before changing.)