[ Blog_Posts ]

Why Your "Fail-Fast" Strategy is Killing Your Distributed System (and How to Fix It)

Why blind fail-fast during leader election causes retry storms, and how bounded retry budgets, failure boundaries, and error normalization create predictable distributed systems.

2026-03-04 Harrison Guo 13 min read distributed-systems resilience redis retry-patterns system-design fault-tolerance nats raft

RPC vs NATS: It's Not About Sync vs Async — It's About Who Owns Completion

The most common microservices mistake isn't picking the wrong transport. It's misreading who is responsible for knowing the work finished. A field guide to completion ownership in RPC, message bus, and event-driven systems.

2026-02-28 Harrison Guo 8 min read distributed-systems rpc nats grpc messaging microservices idempotency system-design backend-engineering event-driven

NATS vs Kafka vs MQTT: Same Category, Very Different Jobs

All three are 'messaging systems.' None of them is interchangeable with the others. A practical breakdown of NATS, Kafka, and MQTT — by the actual design axes that determine which one breaks when you misuse it.

2026-02-24 Harrison Guo 9 min read distributed-systems messaging nats kafka mqtt event-driven iot architecture backend-engineering system-design

Docker × Kubernetes: What They Really Changed (It's Not What You Think)

Docker is not a virtual machine. Kubernetes is not a container tool. Fifteen years in, both are misunderstood — and misused — as a result. A working engineer's explanation of what they actually changed.

2026-02-21 Harrison Guo 10 min read docker kubernetes containers devops infrastructure cloud-native backend-engineering system-design cgroups linux-namespaces

Scale-Up vs Scale-Out: Why Every Language Wins Somewhere

The 'which language is fastest' benchmark wars miss the real question. Rust, Go, Java, and Python aren't competing on the same axis. They're tuned for different scaling strategies — and picking the wrong one costs you years.

2026-02-20 Harrison Guo 9 min read programming-languages system-design scale rust golang java python architecture backend-engineering performance

Testing Real-World Go Backends Isn't What Many People Think

The unit-vs-integration framing is a junior lens. Production Go backends need a different taxonomy: deterministic tests, contract tests, race tests, and fidelity tests. The ones that actually catch production bugs.

2026-02-18 Harrison Guo 10 min read golang go testing backend-engineering distributed-systems race-conditions contract-testing production software-engineering

Observability and Cost Attribution: Why One Pipeline Isn't Enough

Tracing systems optimize for signal-to-noise. Billing systems optimize for accuracy and auditability. They look similar and they are not the same thing. A dual-path architecture for running both without cross-contamination.

2026-02-15 Harrison Guo 10 min read observability billing cost-attribution opentelemetry distributed-systems architecture backend-engineering system-design metrics tracing

Go Context in Distributed Systems: What Actually Works in Production

context.Context is not documentation, not a metadata bag, and not optional. A production-hardened guide to cancellation propagation, the background-goroutine trap, and the patterns that keep services alive when downstreams slow down.

2026-02-13 Harrison Guo 9 min read golang go context concurrency distributed-systems cancellation goroutines errgroup production backend-engineering

Go's Concurrency Is About Structure, Not Speed: chan and context as Lifecycle Primitives

After a few years writing production Go, I stopped thinking of chan as a data pipe and context as a parameter. They're both lifecycle primitives — chan draws the boundary of 'how many alive', context draws the boundary of 'when to die'. Here's why that mental model changes the code you write.

2025-11-21 Harrison Guo 10 min read golang go concurrency channels context backpressure worker-pool distributed-systems backend-engineering go-design

IronSys: A Production Blueprint for Modern Concurrency

After Four Pillars of Concurrency, the natural question: what does a system actually look like when it uses all of them deliberately? IronSys is a composite blueprint — the concurrency architecture I'd build today if I were starting over, with the trade-offs each choice buys.

2025-10-22 Harrison Guo 10 min read concurrency system-design golang architecture distributed-systems backend-engineering csp actors production

[ Blog_Posts ]

[ Connect_With_Me ]