I design parts your shop can build, and write the software that tracks them.

Flutter · Drift · PowerSync · Supabase

A Windows and Android app for construction schedule and progress tracking, built from the site side of the problem rather than the office side. Built so a crew on different devices is looking at the same schedule.

About 24,000 lines of Dart across 55 files. Tasks carry real dependencies — start or finish, plus a lag in days — feeding a critical-path calculation, so one delay propagates down the chain instead of every task being scored on its own: a task with no problem of its own still reads as behind when a predecessor pushed it. Slippage is measured against a locked baseline rather than a plan that quietly moved, and the project's "days behind" figure is the worst task's graph-aware slippage, not a naive date comparison. Offline-first by design — the UI reads a local SQLite database managed by PowerSync, which syncs to Supabase Postgres in the background whenever there is signal. Photos, invited collaborators, and every write stamped with who made it and when.

• Dependency-aware critical path
• Locked-baseline slippage
• Offline-first, syncs when it can
• Gantt with baseline overlay
• CSV schedule import
• Per-task photo evidence

PWA · Cloudflare Workers · D1

An installable progressive web app that runs my week, and the reason this site looks the way it does.

Cloudflare Pages front end talking to a PIN-gated Cloudflare Worker over a D1 database, with a bundled offline fallback so it still opens with no signal. Service worker, installable on the phone, auto-deployed from GitHub on every push. Three visual themes, including a scroll-driven 3D solar system.

• Installable PWA, offline-capable
• Worker + D1 CRUD API
• PIN-gated, CORS-locked
• CI auto-deploy on push

PWA · IndexedDB · Supabase

A phone-first expense tracker that works with no signal at all, and syncs to a second phone when there is one.

Six pages — overview, expenses, income, debts, budget, health — with no build step, no npm and no CDN, because there is no application server here and plain HTML and JavaScript is the smallest thing that works. Expenses, income and debts live in IndexedDB on the device; categories, targets and the daily log in localStorage. Supabase sync sits on top as best-effort only, over plain fetch against the REST API rather than the client library, and every sync call no-ops silently when there is no network — so the app never depends on a connection to keep working. The whole thing counts in pay cycles rather than calendar months: "this month" means the 25th to the 24th, because that is when payday lands. Link an expense to a debt and the balance comes down with it.

• Installable PWA, fully offline
• Device-first storage, no accounts
• Two-phone sync, no client library
• Pay-cycle months, not calendar months
• Whole-app export and restore

Cloudflare Workers · D1 · Work in progress

One inbox for every channel that carries work — WhatsApp, SMS, calls, email, and the conversation you had standing on site — so nothing agreed in passing quietly disappears.

Everything lands as needs triage and stays there until it is given an urgency. That is the whole mechanism: an item cannot sit unseen. Phase 1 is deployed and verified — a PIN-gated mobile web app on a Cloudflare Worker over D1, quick-add for every channel, open and done tabs, and a shared ingest webhook that dedupes repeated calls. Phase 2's code is written and deployed too: Outlook ingest over OAuth against Microsoft Graph on a five-minute cron, and SMS and call capture from the phone. What is left there is account setup, not code. WhatsApp automation is deliberately not built — Meta's Tech Provider mandate put it behind a real monthly fee, and typing those few in by hand does not yet cost that much.

• Phase 1 live and verified
• Worker + D1, no server to run
• Deduping ingest webhook
• Outlook via Graph on a cron
• Triage-first: nothing sits unseen

Python · DSP · Machine learning

Turns the bare desk around your laptop into three tap-triggered hotkeys, using nothing but the built-in microphone.

Real signal processing, on Windows, against a laptop's dual-array mic. A tap is caught by streaming onset detection, reduced to a ten-number feature vector — RMS, peak, crest factor, zero-crossing rate, where in the window the attack falls, spectral centroid, spread, rolloff and flatness, and the level difference between the two mic channels, which is what makes left and right separable at all — then classified by a scaled logistic regression trained on your own desk. Calibration captures background noise as a real negative class, not just a threshold. Two genuine safety nets, ambiguity rejection and novelty rejection, keep it silent on an uncertain read instead of firing the wrong key. There is also an experimental block-NLMS echo canceller that subtracts your own speaker output from the mic before detection — the same family of technique video calling uses — so music does not set off taps.

• Streaming onset detection
• Ten-feature vector, incl. inter-channel level
• Logistic regression trained per desk
• Ambiguity + novelty rejection
• CLI and desktop GUI, packaged installer

Electron · Web Audio · Spotify

A desktop visualiser that draws whatever the machine is playing — any app, any source — with time-synced lyrics over the top.

There is no file picker. It takes system audio loopback, so it reacts to whatever is actually coming out of the speakers, and runs a 1024-point FFT over that. Two modes: the album artwork, and a neon heart on fire whose shape and position never move — only colour, line weight and glow answer the volume, because a heart that jumps around the screen reads as a glitch rather than a pulse. Spotify is wired in over PKCE OAuth to poll what is playing, and lyrics come from LRCLIB as timed .lrc files, cached to a folder you choose. Point several machines at the same network share and they all read and write one lyrics library. The desktop build adds a borderless always-on-top miniplayer that genuinely mirrors the main window: capturing it as an OS window kept grabbing the wrong one, so the main process screenshots its own web contents thirty times a second and streams the frames over IPC instead, with the mini window's controls relaying commands back. Frame throttling is disabled on purpose. Chromium slows timers on an unfocused window, and that alone was enough to walk the lyrics out of sync while alt-tabbed. One codebase, three targets: a portable Electron .exe, an installable PWA with a service worker, and an Android build generated through Capacitor.

• System audio loopback, not a file picker
• Album art and heart-on-fire modes
• Spotify PKCE auth, now-playing poll
• Timed .lrc lyrics over a shared folder
• Mirrored always-on-top miniplayer
• Electron, PWA and Capacitor from one source