Platform & Infrastructure

Build the boring parts once.

Every product on this site — and the private client work behind it — stands on the same substrate, built the way I'd build it at work rather than the way side-projects usually get built. The core is a shared Go platform library: authentication and identity, session management, storage, migrations, and mail, written once, hardened once, and consumed by MemberDex, the PlayProtocol / LAXProtocol backend, and a private client portal.

Around the library sit matching client shells: a SwiftUI app shell that gives every iOS app the same login, biometric unlock, and 2FA flows; a React admin shell for the web consoles; and native Kotlin / Jetpack Compose counterparts on Android. The payoff is compounding: each new product starts with identity, storage, admin, and ops already solved — the marginal product costs a fraction of the first one.

Authentication is the platform's spine.

Every engagement gets a front door.

Client work runs through a portal built on the same platform core — no shared passphrases, no email-attachment archaeology. Each engagement gets its own branded workspace: a dashboard of project updates, file exchange, tools, and scheduling, behind per-user accounts with magic-link sign-in for clients and the full identity stack underneath.

Two layers: a fleet I run, an edge I rent.

Application backends run on a small self-hosted fleet — Linux servers behind a Caddy reverse proxy, services managed by systemd, scheduled work under launchd on the build side. The fleet also carries its own developer infrastructure: self-hosted Git hosting (Forgejo) for every private repo, and self-hosted Jitsi video conferencing for client calls, so meetings don't route through a third party.

Static marketing sites live on the Cloudflare edge: Pages for the sites themselves, Pages Functions for the small pieces that need code at the edge, KV and R2 where client tooling needs state and file storage. Every site ships a hashed Content-Security-Policy — no unsafe-inline — and CSP violations report to a first-party collector running as an edge function, because shipping visitor-adjacent data to a third-party collector would sit badly next to the privacy pages.

The same principle runs all the way down to the type. Every typeface is self-hosted — the font files are vendored into the origin and served from it, so no page load fetches type from anywhere else: no Google Fonts, no font CDN, nobody learning a visitor's IP address from a request that visitor never chose to make. The vendoring step discovers which families a site actually uses from its own markup rather than from a hand-kept list, because the hand-kept list is the part that goes stale — the first measurement of this site found three families and the true answer was five, two of them loaded only by pages deeper in.

Backups are age-encrypted and verified by restoring them — a nightly round-trip with a checksum compare, because a backup that has never been restored is a hope, not a backup.

The toolchain itself is pinned the same way: a Nix flake provides the identical Go compiler and analysis tools on every host — the dev machines, the CI runner's Linux VM, and the deploy cross-compile target — so "works on my machine" isn't a category of bug that exists here.

The full toolbox.