Home/Work

Things I've built.

Tools, workflows, and sites — described by what they actually do. Source files are private for now; build notes follow on Writing as each tool earns its own piece.

18 projectsBuilt in public

Software development

Larger systems built end to end — operational software, native apps, and AI products. Told architecture-first: the design decisions and the numbers, not the client names. All of them sit under the same security-by-design discipline this site documents — threat-modelled, gated, and evidenced. How that discipline works →

Stock Intelligence Platform

A store stock system that grew up in public: it started as a Python desktop tool doing counts, sales and waste from CSV exports, and evolved into a four-layer production platform — React front end, Express API, dedicated service layer, MySQL under Drizzle. The interesting part is the order brain: demand forecasting over 21,000+ sales records with confidence-scored suggestions and a four-tier urgency model, built by someone who has actually run the stock counts it replaces. Performance is engineered, not hoped for: connection pooling, per-query monitoring, sub-200ms p95 responses at an 82% cache hit rate. Security the same way — multi-tier rate limiting and hardened headers are part of the middleware stack, not bolt-ons.

ReactExpressMySQLDrizzleForecasting

QSR Ops Platform

One operational backbone for a quick-service restaurant: staff scheduling (a full rota planner with shift templates, rota groups and a role library), stock and count sessions, budgets, sales, suppliers, recipes linked to stock, recruitment, deliveries and document management — a dozen-plus domains under twenty versioned migrations in one modular Express + Knex backend with a React front end. The design bet is that scheduling and stock belong in the SAME system, because on a real shift the rota decides who does the count. Built from inside the operation it serves.

ReactExpressKnexSchedulingOperations

Task OS

A task platform that scales from a personal list to team workspaces, then extends into native apps. The web core is Next.js with a Node/Postgres/Redis backend: unlimited subtask nesting over a dependency engine that refuses circular dependencies at write time, real-time collaboration over Socket.io, and role-based team workspaces with activity feeds. On top of that sits a native SwiftUI macOS app built on a shared set of Swift models — platform-specific UI over shared business logic through the same API — with an iOS sibling planned on the same foundation.

Next.jsPostgreSQLSocket.ioSwiftUIRedis

Finance RPG

An iOS budgeting app built on one idea: your real transactions should drive a game. Checking in on your budget earns XP, spending patterns spawn quests, and staying on plan levels you up — the RPG ledger is computed by pure generator functions over the transaction history, so the game state can always be re-derived and never drifts from the money. Native SwiftUI throughout. Several of the build's bugs and design calls are written up in the articles on this site.

SwiftUIiOSGamificationPure Functions

Market Engine

A market-data and trading-analytics stack rebuilt the hard way: the first generation ran Flask with ML prediction and backtesting; the rebuild is async-first FastAPI over asyncpg with the indicator maths (EMA, RSI, ATR) as its own tested calculator. The distinctive discipline is temporal integrity — a CI-enforced test suite that proves no calculation ever reads data from the future, because a backtest that peeks ahead is a very convincing liar.

FastAPIPostgreSQLasyncpgCIBacktesting

Web development

Sites and web products shipped for the world to use — starting with this site, with live capability demos to follow.

Uigen

Natural language in, production UI components out. A prompt fans out to three parallel generations streamed live over server-sent events, so you compare real variations instead of regenerating one guess; picked designs land in a versioned library with automatic screenshot previews, and any component can be expanded into a full multi-section page. Next.js 15 + React 19 with Prisma/Postgres and NextAuth underneath, a catalogue of 150+ models behind one interface, and a spec-driven build process — forty-plus specs and counting.

Next.jsReact 19OpenRouterSSEPrisma
Editorial illustration of a workshop seen through a shop window, with a hand lifting a freshly-printed page through an open door.

This Site

Next.js 15, static export, MDX, custom design system — built entirely in public with Claude Code. Every decision documented in the devlog.

Next.jsTypeScriptMDXClaude Code

Financial Tooling Website

A suite of UK financial calculators — mortgages, tax, stamp duty, savings — wrapped in an editorial layer that explains the numbers. Next.js throughout, built search-first: structured data, telemetry-instrumented indexation, and content written to answer the exact questions people type.

Next.jsSEOStructured DataContent

Tutoring Education Website

A tutoring business’s website, first built twelve years ago — early proof of shipping for real clients. It’s now being reborn: the redesign seeded a productised WordPress block theme with a companion plugin, currently half-built with its first live instance running — launching as a product in its own right.

WordPressBlock ThemeLegacy → Product

Hospitality Website

A restaurant’s website, built twelve years ago — menus, bookings and brand presence in the pre-framework era. Part of the early client work that taught the lesson the newer builds run on: the site is never the product, the customer walking in is.

Client WorkLegacy

Tooling

Tools first — several of them embodying a way of working. Roadmap, DVLAW and Park keep every repo's story durable across sessions (what's planned, what shipped, the ideas caught mid-build); the rest are standalone builds that earn their keep daily.

Editorial illustration of a wall of pinned phase cards, with open books above and a shelf of stacked tickets below.

Roadmap

The forward-looking spec for every repo: vision, first principles, scaffold, brainstorms, a phased plan, and a decision archive — held as a living document, not a checklist. Phases are written in sequence with their dependencies named, and architectural decisions are archived with their reasoning so they don't evaporate between sessions. Three git hooks make the discipline mechanical: active phases surface at session start, a pre-commit check ensures a phase commit also updates the roadmap, and a stop-hook reminder catches unlogged scope changes.

PythonGit HooksClaude CodeWorkflow
Editorial illustration of an assembly track threading multiple mechanical gates, with raw pages at one end and a stamped finished page at the other.

DVLAW

A workflow and toolchain that turns each repo's append-only devlog into honestly-sourced articles. Three layers: the mechanical devlog (one dense paragraph per shipped change), a six-step thesis-first gate (triage → propose → clarify → draft → edit → ship), and published posts that cite the exact devlog entries they draw from. The gate exists because drafting from memory produces fluent prose against the wrong premise — thesis-first discipline strips the prose so the argument is what gets judged, not the fluency. Backed by a SQLite index that mirrors every tracked repo for cross-repo queries, a registry, and an audit trail of every article decision.

PythonSQLiteClaude CodeWorkflow
Editorial illustration of a pneumatic tube splitting into three branches above three differentiated bins, with a sketch on the workbench below.

Park

A one-command idea-capture tool. Mid-build, an idea strikes — `park` writes it into the roadmap's brainstorm section, the backlog, and an audit trail in one move, with full provenance: a condensed excerpt of the conversation that produced it, plus a resume hint pointing back to exactly what you were working on. It replies with a single line, so you drop the thought and get straight back to the task instead of losing your place.

PythonClaude CodeProvenance
Editorial illustration of a folded paper map opening into a multi-storey pop-up structure with five distinct silhouettes.

Atlas

A JSON-driven living-document generator. One JSON file becomes one self-contained, interactive HTML "atlas" — hash-routed drill-down, Monte Carlo schedule simulation, a risk register, a security model (threats, mitigations, principles, compliance), and a devlog view. No build step, no dependencies. Every section is optional, so the same tool produces project plans, constitutions, runbooks, or knowledge bases.

Node.jsJavaScriptHTML

Simply Visual

Details to follow.

Editorial illustration of two adjacent print workshops with an open drawer of past index cards between them.

Image Harness

A two-layer image pipeline for the site's hero art. One model writes a tight scene brief under a strict word budget; a second model generates the image from it. A brief ledger tracks what's already been produced so adjacent posts don't converge on the same composition. Built after an A/B evaluation rejected an earlier model whose mandatory prompt-rewriting caused systematic failures.

PythonGeminiWorkflow

Ways of working

The philosophies underneath the output. Each links to its full public write-up.

Security by Design

The discipline behind every build on this page: threats modelled before the spec exists, controls chosen at spec time, an automated gate that refuses to start a build with unresolved security gaps, and an evidence trail after every phase. The full philosophy — six practices, a 20-document framework library, priority tiers — is public, with this site’s own controls as the proof.

STRIDEOWASPEvidencePhilosophy

Build in Public

Every repo keeps an append-only devlog; every shipped change becomes one dense, honest paragraph; the best of those become articles that cite the exact entries they draw from. The tooling above (Roadmap, DVLAW, Park) exists to make that discipline mechanical — the writing on this site is its output, receipts included.

DevlogArticlesProvenancePhilosophy