Cloud-Native Go

What cloud-native means and why Go is its native language — static binaries in tiny containers, the 12-factor principles, and what 'production-ready' adds on top of 'it compiles'.

Packaging a Go service into a tiny, secure image — multi-stage builds, scratch/distroless bases, static linking, non-root users, and the version stamping that makes images traceable.

The Kubernetes objects your Go service lives in — Pods, Deployments, Services, ConfigMaps/Secrets — how a Deployment gives you self-healing and scaling, and how the app receives its identity and config.

Telling Kubernetes the truth about your service — liveness vs readiness vs startup probes, and graceful shutdown that drains in-flight requests so deploys never drop traffic.

Getting a Go service from commit to production safely and repeatably — the CI vs CD split, what a Go pipeline runs, and GitOps: Git as the single source of truth a controller reconciles toward.

Shipping a new version without dropping traffic — rolling, blue-green, and canary releases, the health-gated promotion that makes them safe, and how readiness probes tie in.

Feeding a service its config the 12-factor way — environment variables and flags, precedence and defaults, fail-fast validation, and how ConfigMaps and Secrets map onto it in Kubernetes.

Running Go without managing servers — FaaS (Lambda) vs serverless containers (Cloud Run), the handler model, cold starts and why Go excels at them, and when serverless fits.

Logs you can actually query — structured JSON with slog, levels, request-scoped fields and correlation IDs, and the rules (no secrets, log to stdout) that make logs work in a cluster.

Measuring a service in aggregate — counters, gauges and histograms, the /metrics endpoint Prometheus scrapes, the RED method, and the cardinality trap that blows up your metrics.

Following one request across many services — traces and spans, context propagation, OpenTelemetry, sampling, and why a trace is the tool you reach for when metrics say 'slow' but not 'where'.

Finding why a service is slow or leaking — Go's built-in pprof (CPU, heap, goroutine, block profiles), the net/http/pprof endpoints, and continuous profiling, when metrics say 'slow' but not 'where in the code'.

Decoupling services with asynchronous messaging — queues vs pub/sub, consumer groups, delivery guarantees (at-least-once and why exactly-once is hard), acks and redelivery, and backpressure.

Designing systems around things that happened — events vs commands, event sourcing and rebuilding state by folding events, CQRS, and the eventual consistency you trade for decoupling.

Reliably publishing events alongside a database write — the dual-write problem, the transactional outbox, and idempotency keys that make at-least-once delivery safe to reprocess.

Taking read load off your datastore — the cache-aside pattern, TTLs and invalidation, the cache stampede and how to prevent it, and the consistency trade-offs of caching.

When (and when not) to split a system into services — bounded contexts and service boundaries, API contracts, the fallacies of distributed computing, and why 'monolith first' is usually right.

How Go services talk — gRPC vs REST, protobuf contracts and code generation, the four call types, and choosing synchronous calls vs asynchronous messaging.

Keeping a service up when its dependencies fail — timeouts, retries with exponential backoff and jitter, the circuit breaker, bulkheads, and graceful fallback.

Moving retries, timeouts, mTLS, and traffic routing out of every service and into the platform — the sidecar/proxy model, what a mesh gives you, and when its complexity is worth it.

Protecting a service from too much traffic — rate limiting vs load shedding vs backpressure, graceful degradation under overload, and why dropping some requests beats collapsing under all of them.

Letting the platform size your service to demand — horizontal vs vertical scaling, the Kubernetes HPA control loop and its replica formula, scaling on the right signal, and scale-to-zero.

Keeping data consistent across services without a global transaction — why two-phase commit doesn't fit microservices, the saga pattern with compensating actions, and orchestration vs choreography.