/ writing
Writing
I write about the systems I actually build — multi-tenant SaaS in Rails and Go, financial integrations, Postgres under load, and shipping my own products. Real code, and the honest parts.
Start here
Streaming uploads over WebSockets in Go with io.Pipe backpressure
Go, WebSockets, and backpressure done right.
Read →Roles that contain roles: an RBAC resolved by a recursive Postgres query
A permission system resolved by one recursive Postgres query.
Read →Low-latency on-device captions in Swift with SpeechAnalyzer
Low-latency on-device speech on iOS 26.
Read →All posts
-
Vendor the small algorithm, don't add the dependency
The reflex to reach for a package for everything is wrong for small, stable, well-specified code. Why I vendored the FSRS-5 spaced-repetition algorithm into my iOS app instead of adding a dependency — and where vendoring is the wrong call.
-
gRPC vs REST: when I actually reach for each (and when gRPC is a mistake)
gRPC vs REST gets argued in the abstract. I've shipped both — a Rails↔Go deploy engine on gRPC, browser uploads on plain WebSockets. Here's my actual rule for choosing, and the cases where gRPC is the wrong call.
-
Streaming a deploy from a Go agent to Rails over gRPC
One-click deploy means running git clone, docker build and docker run on a remote box and showing every log line live. How I stream that: a Go agent that pipes each command's output over a gRPC server-stream to a Rails control plane, which turns it into a live deploy log.
-
Capturing a bug in the browser: wrapping fetch, XHR and console (and redacting PII first)
A screen recording shows what broke, not the console error or failed request behind it. How to capture those by wrapping fetch/XHR/console without breaking the page — and strip passwords, tokens and card numbers client-side before anything leaves the browser.
-
Streaming uploads over WebSockets in Go with io.Pipe backpressure
A browser MediaRecorder emits video chunks for minutes on end. Buffering each recording in RAM doesn't scale. How I stream chunks straight to storage over a WebSocket in Go, using io.Pipe so the socket buffer becomes the backpressure.
-
Low-latency on-device captions in Swift with SpeechAnalyzer
Transcribing a 50-minute audiobook chapter before showing the first caption is unusable. How I get the first line in ~1–2s: a playhead-windowed AsyncStream feeding iOS 26's SpeechAnalyzer, with the feeder and results consumer racing on separate tasks — all on-device.
-
Vendoring FSRS spaced repetition as a pure Swift function
My audiobook app turns highlights into flashcards scheduled by FSRS-5 — the algorithm Anki uses. Why I vendored the math as a pure, dependency-free, unit-testable Swift function instead of adding a package, and how the scheduler actually works.
-
Syncing invoices to QuickBooks when the other side keeps changing under you
Third-party accounting APIs don't fail cleanly. Customers get deleted in QuickBooks behind your back, tokens expire mid-request, and retries duplicate records. Here's how one Rails integration stayed idempotent and learned to heal itself.
-
The Postgres features I reach for before I reach for a cache
A slow multi-tenant Rails app usually isn't slow because Postgres is slow. It's slow because the work is being done in Ruby that Postgres would do better. DISTINCT ON, array overlap, and full-text search — with the honest limits.
-
Roles that contain roles: an RBAC resolved by a recursive Postgres query
When a role can inherit other roles, permissions stop being a list and become a graph — and graphs are where the ORM taps out. Here's a role system resolved in one WITH RECURSIVE query, cached per tenant, and enforced through method_missing.
-
Schema-per-tenant Rails, and the bug that only shows up in a background job
Isolating tenants in separate Postgres schemas is the easy 90%. The 10% that bites is keeping that isolation when work leaves the web request and runs on an SQS worker. Here's how we carried the tenant across the queue.
-
Wiring up an open-banking feed in Rails without leaking or getting locked in
Bank aggregators are slow, asynchronous, and full of PII you must never log. Here's how I integrated one: a swappable provider, encrypted credentials, a recursively-redacting request logger, and a poll-until-done connection job.
-
Auto-categorizing bank transactions with Postgres fuzzy matching (no ML)
'UBER *EATS 8829' and 'UBER* EATS' are the same recurring expense, but the strings don't match. How I auto-categorize bank feeds with Postgres levenshtein() and soundex() against a user's own history — no machine learning.
-
Charging a card once in Rails: the guard I shipped, and the gaps I didn't close
A payments flow is 'at least once' at every layer — retries, double-clicks, replayed webhooks. Here's the guard that stops the common cases, an honest accounting of the ones it doesn't, and how I'd close them.
-
Building an invoice tax engine in Rails that accountants trust
Tax-inclusive and tax-exclusive pricing round differently, and one cent of drift makes an invoice look broken. How I built a tax engine with the Strategy pattern, BigDecimal, and spreadsheet-verified golden-master tests.
-
Polymorphic models in Laravel: one table, two different records (Eloquent morphs)
A CRM tracked two kinds of record that shared almost no fields but flowed through the same statuses, teams, and dashboards. I modeled it as one table with a polymorphic child — and hung the whole framework off the shared root. Mostly it worked; a couple of seams are worth showing.
-
Aggregating in SQL vs in memory: a Laravel dashboard performance lesson
Two chart methods in an old Laravel CRM — one aggregates counts in SQL, the one right below it loads every record into memory and sums them in a PHP closure. A dashboard performance lesson at millions of rows, and the junior-to-mid growth arc behind it.
-
Strangling a legacy database into Laravel (my first big migration, mistakes included)
My first serious Laravel app wasn't greenfield — it had to swallow years of data from a legacy call-center system with tables named `lead` and `hotkey`. Here's the anti-corruption layer and the chunked migration engine I built, and the parts I'd do differently now.
-
Splitting money in a marketplace: Stripe Connect, destination charges, and getting hosts paid
A marketplace can't just charge a card — the money has to split between the platform and the host, and the host has to be onboarded for payouts. The real Stripe Connect wiring: Express accounts, hosted onboarding, and a destination charge that skims the platform fee.
-
The availability search that loaded every booking into memory — a Rails date-range fix
A marketplace 'search by dates' feature quietly became O(bookings × listings): it pulled every booking in the database into Ruby and eliminated listings one query at a time. The fix was a single overlap query the codebase already had — and never used.