Posts

Writing Testable Go Code Without Mocking Everything

Real implementations over mocks, test fixtures that work, and design patterns that make code testable without generating mock files for every interface.

Profiling Memory Allocations in a High-Throughput Go Service

How we reduced GC pauses from 50ms to 2ms by finding hidden allocations. Practical pprof techniques, escape analysis, and the optimizations that actually matter.

Worker Pools and Bounded Concurrency in Go

Practical patterns for controlling concurrency: worker pools, errgroup, semaphores, fan-out/fan-in, and backpressure. How to process work concurrently without overwhelming your system.

Graceful Shutdown in Go Is Harder Than You Think

Handling in-flight requests, Kafka consumers, database connections, and Kubernetes termination signals correctly. The details that tutorials skip.

Error Handling Strategies Beyond if err != nil

Structured errors, error wrapping done right, sentinel errors vs behavior checking, and patterns that make debugging production issues actually possible.

Dependency Injection in Go Without Frameworks

Manual DI, functional options, Wire code generation, and why Go doesn't need Spring-style containers. Practical patterns for building testable, maintainable applications.

Why Our Microservice Needed a Circuit Breaker (And How We Built It)

Real latency cascades we encountered, how they took down our system, and the circuit breaker implementation that saved us.

When to Go Distributed: Real Talk on Building Systems with Go

After years building distributed systems, here's my honest take on when you should consider the complexity, and why Go excels when you do.

Context Propagation Patterns in Large Go Codebases

When to pass context, when not to, and the common mistakes that lead to leaked goroutines, missed cancellations, and debugging nightmares.

Structuring a Go Monolith So It Can Become Microservices Later

Practical module boundaries, package organization, and the patterns that make future decomposition possible without rewriting everything.