cat ~/posts/*

The hidden costs of WebSockets — persistent connections, scaling nightmares, server bills, and when simpler alternatives like SSE or polling actually win.

The fundamental trade-offs in backend engineering — consistency vs availability, latency vs throughput, simplicity vs flexibility, and how to navigate them.

Patterns for building systems that handle real-world traffic — load shedding, circuit breaking, graceful degradation, and capacity planning.

An honest assessment of Go's strengths and weaknesses — when to choose Go over Node.js, Rust, Java, and when to avoid it.

Hard-won system design principles from building production systems — on complexity, trade-offs, data modeling, and the decisions that actually matter.

Implementing rate limiting in Go — token bucket, sliding window, distributed rate limiting with Redis, and per-user vs global strategies.

Complete guide to graceful shutdown in Go — signal handling, connection draining, worker completion, and Kubernetes integration.

Setting up structured logging, distributed tracing, and metrics in Go services — slog, OpenTelemetry, Prometheus, and the observability stack.

Patterns for building stateless Go services that scale by adding instances — session externalization, distributed locking, and load balancing strategies.

How I structure Go API services for maintainability and scale — handler/service/repo layers, dependency injection, and practical project layout.

Practical patterns for writing concurrent Go code that doesn't race — mutexes vs channels, atomic operations, and race condition detection.

Deep dive into Go's context package — propagation patterns, timeout chains, value storage, and designing systems that cancel gracefully.

Common causes of goroutine leaks in Go and how to prevent them — context cancellation, channel cleanup, and leak detection in tests.

How to build worker pools in Go that handle backpressure, graceful shutdown, dynamic scaling, and error recovery without goroutine leaks.

Beyond goroutines and channels — fan-out/fan-in, pipelines, semaphores, singleflight, and errgroup patterns for production Go code.

Practical memory optimization in Go — sync.Pool, arena patterns, slice pre-allocation, string interning, and reducing GC pressure.

Techniques that cut our API P99 latency from 800ms to under 100ms — connection pooling, query optimization, caching layers, and async processing.

A field guide to Go performance tuning — GC tuning, allocation reduction, efficient I/O, and the benchmarks that actually matter.

How the Go scheduler works under heavy load — GOMAXPROCS, goroutine scheduling, preemption, and what happens when you spawn a million goroutines.

Concrete optimizations for Go HTTP services at scale — connection reuse, zero-alloc patterns, efficient serialization, and database query tuning.

Practical guide to profiling Go services using pprof, trace, and runtime metrics — finding CPU hotspots, memory leaks, and goroutine leaks in production.

Battle-tested patterns for running event-driven Go systems in production — transactional outbox, consumer groups, event replay, and schema evolution.

Architecture and implementation of a Go event pipeline handling millions of events — fan-out, batching, buffering, and backpressure.

Patterns for building Go workers that consume from message queues reliably — graceful shutdown, health checks, backpressure, and poison message handling.

Strategies for dealing with partial failures in Go — circuit breakers, retry budgets, fallbacks, and the Saga pattern for distributed transactions.

Architectural patterns for building Go microservices that handle thousands of requests per second — connection pooling, batching, and backpressure.

Building production-grade background job processing in Go with exponential backoff, dead-letter queues, and idempotent handlers.

Practical lessons on event schemas, eventual consistency, idempotent consumers, and the realities of building event-driven systems in Go.

How I built a distributed task queue in Go with priority scheduling, retries, dead-letter queues, and horizontal scaling.

A practical playbook for large-scale MySQL migrations using dual-write, shadow tables, and incremental cutover — with zero downtime.

Hard-won lessons from building production systems — on simplicity, failure modes, databases, and the things nobody teaches you in tutorials.

How to trace requests across services using AsyncLocalStorage, correlation IDs, and OpenTelemetry in a Node.js microservices architecture.