I build software that is fast by default, honest about failure, and pleasant to touch.
Six years shipping production systems — realtime engines, data pipelines, and the interfaces on top. Currently senior developer at Halcyon Systems.
The short version, for people who read sidebars first: I make the invisible parts of software visible — in speed, in reliability, in feel.
I care about the part nobody sees: the sync engine, the queue, the 200 milliseconds that decide whether a tool feels alive or merely loads.
I started out building websites for a design studio in Porto and got pulled deeper — first into the frontend, then into everything underneath it. These days I work across the whole stack, but my home turf is realtime: systems where state is shared, latency is visible, and correctness isn't optional.
Away from the keyboard I photograph brutalist buildings, run slowly along the Tejo, and maintain a slightly obnoxious collection of mechanical keyboards. I write about systems design when something surprises me, and I mentor two junior developers who now routinely out-argue me in code review.
Five things I've shipped that I'd ship again. Hover a row for the plate; open it for the story.
A conflict-free sync layer keeping 40,000 concurrent editors consistent without a lock in sight. Custom CRDT core written in Rust and compiled to Wasm; median sync round-trip under 9 ms on European routes. I designed the persistence model, the presence protocol, and the offline queue that survives a two-week flight.
Reconciliation platform matching two million transactions a night against bank feeds. I built the rules DSL that finance teams write themselves without engineering tickets, and the workflow engine that retries, back-fills, and never wakes anyone at 4 a.m. unless it's truly on fire.
Self-hosted mapping toolkit that renders vector tiles at 120 fps on commodity hardware. It started as a weekend renderer and grew into a 4.1k-star project with thirty-odd contributors. My favourite bug report to date involved a fishing boat, a VPN, and a very confident coordinate system.
Ingestion pipeline for a wearable startup: 60,000 sensor readings a second, exactly-once semantics, and backpressure that degrades gracefully instead of dramatically. Cut storage costs 38% by downsampling on write rather than on read — a decision I'd defend in court.
A 2 kb state library built on proxies and signals, with an API small enough to memorise on a train. 12,000 weekly downloads, a README people actually read to the end, and issues answered within 24 hours for three years running.
Older work under NDA — full archive on request
Realtime collaboration: CRDT sync layer serving 40k concurrent editors, plus the observability stack that keeps it honest.
Built ingestion pipelines processing 2B events a day; cut warehouse costs 38% and onboarding time in half.
Shipped 14 client products end-to-end; learned that deadlines are a design constraint, not the enemy of design.
Thesis on conflict-free replicated data types — back when explaining CRDTs at parties was still social suicide.
Grouped by where they live. Opened, they explain why.
Rust when a 3 a.m. pager is on the line, TypeScript for everything user-facing, Go for services that just need to quietly work for a decade. And SQL — which I consider a love language.
I care about the last four pixels and the first hundred milliseconds. Budget-driven UI work, canvas and WebGL when the DOM gives up, and CSS treated as an engineering discipline rather than an afterthought.
Event-driven by default. Postgres until it genuinely hurts, then careful surgery instead of a rewrite. I've run Kafka in production and lived to document it.
Everything as code, trunk-based, feature-flagged. Observability first: if it isn't graphed, it didn't happen.
Next availability — Q1 2026 · Remote-friendly · UTC±3