Blog
Engineering notes
This isn't a resume summary, it's the architecture and debugging problems every senior engineer eventually runs into.
OAuth token management at scale: what breaks going from one account to ten
Integrating OAuth for a single account is a tutorial. Doing it for dozens of centrally managed accounts is a completely different engineering problem.
Outbound rate limiting: why throttling yourself is part of the engineering
Almost the entire conversation about rate limiting is about protecting your own API from external abuse. The less discussed half is throttling yourself against the third-party APIs you consume.
Solving NP-hard problems with real tools, not reinventing them
The temptation to implement your own optimization algorithm is strong and almost always wrong. When leaning on specialized tools is the correct engineering call.
Web vs. native: when a single constraint decides the whole architecture
The choice between web and native is rarely decided by technology preference. It's almost always decided by a non-functional requirement that seems secondary until it isn't.
Proxy rotation: the unglamorous engineering that decides if your infrastructure survives
Behind any system that makes lots of outbound requests sits a problem that isn't glamorous but is critical: knowing, before it's too late, which resources have stopped working.
Debugging a UI race condition: a real case
A bug that only happened sometimes, only in a certain click order, and what it teaches about debugging shared state on the frontend.
Why browser APIs are moving from imperative to declarative
The shift from intercepting network requests line by line to declaring rules upfront isn't a syntax trend. It's a direct response to a security and performance problem.
Graceful degradation: designing so the secondary fails without taking down the essential
When a non-critical component depends on an external service, the most important design question is what happens the day that service stops responding.
Idempotency: the problem everyone thinks they understand until the first duplicate arrives
Almost every engineer can define idempotency in an interview. Very few systems implement it correctly where it actually matters.
Concurrency in bidding systems: when two users can't both win
A real-time auction system concentrates nearly every classic concurrent-write challenge into a single problem. What it teaches about designing for the exact moment two people compete for the same thing.
Background services on Android: a constant negotiation with the OS
Why keeping a process alive in the background on Android isn't a code problem, it's about negotiating guarantees with a system designed to kill processes.
How to design a referral program that can't be gamed
Every automated monetary incentive is, underneath, a security system. The rules that separate a healthy referral program from one that self-destructs.
Direct integration vs. intermediary: the trade-off nobody discusses in time
Using an intermediary provider speeds up launch. Integrating directly with the platform gives full control. The right call depends on a question rarely asked at the start.
Stateless vs. stateful: when simplicity beats control
Two legitimate ways to solve the same messaging problem, and how to choose between them without falling into the dogma of 'always simple' or 'always robust'.
Designing for auditability from the data model, not as a reporting layer
When a business needs to answer 'what exactly happened to this,' the answer can't depend on reconstructing history afterward. It has to be in how the entities were modeled from the start.
Extending a third-party framework without touching its core
When the right answer isn't forking or patching, but designing your feature as a well-behaved external citizen of the system you're extending.
Letting data expire on purpose: TTL as an architecture decision
Not all data deserves to live forever. Designing expiration into the data model, instead of treating it as a cleanup job bolted on later, completely changes a system's scaling profile.
Designing for a runtime that can die at any moment
Manifest V3 forces a rethink of how you keep state alive that used to be a safe assumption. What it teaches about designing systems for ephemeral environments.
Connection pooling: the invisible optimization that decides if your system scales
Opening a new connection per request looks harmless until traffic grows. Why connection pooling is one of the most underrated performance decisions.
Retries that make the outage worse: the retry storm problem
Retrying a failed request looks like the obvious fix. Without coordination, it's one of the most common ways to turn a small failure into a full outage.