Posts
Who Else Reaches Into This Database?
The blocking question for any extraction. On enumerating every service that touches a shared database with direction and evidence, discovering which entities are keyed to an external provider — and why a single-provider key quietly makes your history depend on a vendor you might replace.
Inventorying Every Surface a Monolith Exposes
You cannot rebuild a service until you know exactly what it promises the outside world. On deriving that list from the code rather than from memory — REST routes, deployed applications, real-time channels, notification triggers — and making the inventory an artefact that tests enforce rather than a document that rots.
Quantify the Failure Before You Redesign It
"Subscribing is unreliable" was the premise for extracting a service out of our monolith. Before designing anything I measured it in the production log group — and the failure wasn't flakiness at all. It was a state machine rejecting purchases it should have accepted, 3,995 times in seven days, behind one opaque error code.
There Are No Solutions, Only Trade-Offs: DDIA Chapter 1 and Four Decisions I Actually Made
The first chapter of Designing Data-Intensive Applications, 2nd edition, isn't about techniques—it's about trade-offs. Reading it against four real backend decisions at a sports platform: monolith vs distributed, shared database vs database-per-service, systems of record vs derived data, and cloud vs self-hosting.
Shared Database Across Microservices: The Migration You're Not Ready to Make
When multiple microservices share a single PostgreSQL database, schema migrations become a coordination problem. Here's how we handle it at R10 with Django, Go, and zero downtime.
Strangler Fig in Practice: Moving a REST API from Python to Go Without Downtime
How we eliminated the Python middleman by adding REST endpoints directly to an existing Go microservice — reusing its service layer, repositories, and async patterns — while keeping the monolith running for 100+ other endpoints.
How DDIA's Stream Processing Concepts Apply to Real-Time Notification Systems
Connecting Designing Data-Intensive Applications' stream processing concepts—event streams, fan-out, backpressure, materialized views, and exactly-once semantics—to real architectural decisions in a live sports notification system built with Go, gRPC, and AWS SNS.
Building a Tiling Window Manager in Pure Go
How I built gowm, a minimal X11 tiling window manager from scratch using Go
Building a High-Performance Push Notifications Service in Go
Building a push notifications service that handles millions of events reliably requires careful architectural decisions. In this post, I'll walk through how I built a notifications backend in Go that processes events via gRPC and delivers push notifications through AWS SNS.
Rewriting a Python Notifications Service in Go: 5x Throughput, 10x Smaller
A deep dive into rewriting a Python asyncio notifications backend in Go, achieving 5x throughput improvement, proper distributed deduplication, and a 10x smaller Docker image.