I design, build and operate a private production estate end to end — architecture, code, infrastructure, security and release engineering. Client and product names are withheld; the engineering is described below.
A five-node Linux server estate running more than twenty production web applications. Relay-based remote execution independent of inbound SSH, content-addressed resumable multi-gigabyte transfers with full SHA-256 verification, immutable releases and recorded rollback state for every deployment.
ERP with double-entry general ledger, CRM with workflow automation, file storage on S3-compatible object storage, real-time chat, video meetings over an SFU, webmail, time and attendance, and a shared identity service — one estate, many tenants.
A full identity provider: OIDC/OAuth2 authorization server with PKCE and RS256, a SAML 2.0 service provider hardened against XSW, XXE and replay, SCIM 2.0 auto-provisioning, and passwordless FIDO2/WebAuthn passkeys — built on the standard library rather than a vendor SDK.
Schema-per-tenant separation for the business applications and PostgreSQL row-level security for the shared ones, with the tenant GUC set at a single authentication chokepoint and FORCE row security so even the table owner cannot read across tenants.
Local LLM inference with per-organisation retrieval-augmented generation over pgvector embeddings, so tenant content is never sent to a third-party model API. Plus a cross-application copilot and rule-based assistants where a model is not warranted.
A browser-based 3D world with vehicle dynamics, physics, day/night simulation and multi-user presence — including draw-call reduction work, GLB asset pipelines, collision and surface-continuity audits, and GPU shader program validation against a hard frame-time budget.
CRDT co-editing over a WebSocket relay with scoped HMAC tokens, behind a suite of document, spreadsheet, presentation, PDF, forms, whiteboard and diagram editors sharing one portable engine core.
The same product surfaced as native applications across platforms — Kotlin and Jetpack Compose on Android, .NET 8 WPF and Qt 6 C++ on Windows, plus packaged desktop builds — with signed releases, in-app updates and CDN distribution.
Point-in-time recovery with WAL archiving and mutual TLS streaming standbys between hosts, encrypted off-host backups with validated catalogs, health probes, and documented failover procedure — designed so recovery is rehearsed, not improvised.
A cloud service that validates, stores and dispatches G-code to networked machines, and a six-axis motion controller on STM32H743 with grblHAL, a Wi-Fi co-processor link and Modbus spindle control — cloud and firmware on the same project.
Digital elevation models from LiDAR point clouds and from synthetic-aperture radar, GPU hillshade and colour-relief rendering for interactive terrain, custom QGIS tooling, a Windows port of a Linux GIS stack, and GPU-backed Kubernetes for the processing workloads.
Per-application credential isolation in systemd units, a WireGuard VPN for administrative access, automated TLS issuance and renewal across dozens of hostnames, least-privilege service users, and hands-on incident response including a live web-shell compromise.
Services that compile and run untrusted code submissions under isolation, across several languages, with per-run resource limits — plus a small compiler toolchain of my own. Running arbitrary code someone else wrote is a containment problem before it is a language problem.
Session-integrity monitoring for remote assessment: camera and behaviour signals scored continuously to flag anomalies rather than accuse. The same detection and tracking discipline as the industrial inspection work, applied where a false positive costs someone their result.
Automatic speech recognition running on my own hardware, so audio is transcribed without leaving the estate — the server-side counterpart to the on-device voice-to-text work in the vehicle cabin.
A durable job and workflow engine with a separate worker pool: long-running tasks survive a restart, retry on their own terms, and report progress rather than disappearing. The unglamorous layer everything else depends on.
Verification agents running on every host in the estate: visual regression polling, release qualification and health verification, so a release is gated on measured evidence rather than on someone remembering to check.
A data and API layer with its own admin console — schema, auth, storage and generated endpoints — so a new application starts from a working backend instead of rebuilding the same foundations again.
Current work, with its honest status. Shipped means in production and in use; in build means the feature exists but its acceptance gate has not passed yet; held means it is finished and waiting on a decision that is not mine to make.
A hiring platform with staged assessments — the first stages are live and in use. Remote proctoring is the stage in build: session integrity is the part that has to be right before anyone relies on a result.
A multiplayer WebGL world on a continuous release train — terrain, roads and rivers, vehicle handling, animal and NPC behaviour. Every release has to clear a measured frame-time gate against a concurrent-client target, and a release that misses it does not ship.
STM32H743 running grblHAL with a Wi-Fi co-processor over USART and Modbus spindle control. Firmware and motion tuning in progress; the cloud service it reports to is already live.
Validates, encrypts, stores and dispatches G-code to networked machines, with two-factor access and object storage behind it. Complete and running; the payment path stays deliberately closed until the gateway webhook is verified end to end.
Video-backed course platform with DRM-protected offline downloads, refunds and ticketing. Pre-launch: the software is qualified, the remaining gates are commercial and legal rather than technical.
Per-site registration, email verification and administration for a fleet of independent sites. Piloted on one site and working; the roll-out across the remaining sites is the outstanding work.
Desktop and mobile clients for the accounting and operations applications, built to work with no connection and reconcile afterwards. Built and tested, held back from release pending a device-qualification pass — shipping an untested build is not a trade I make.
The independent work above is not a handful of demos. This is what it adds up to in version control — queried from the inventory database, not typed out here.
Everything I build on my own account is under version control, and every repository is private. They stay that way: the clients, products and domains behind them are not mine to publish.
What the count is for is shape and scale — the breadth of subjects below, each one carried from an empty repository to something running in production, and the languages that came with them. The languages were chosen per target rather than per preference: Kotlin and Swift because the phone demanded it, C and C++ because the microcontroller did, Python because the server did.
The same product delivered as a native application on every platform it is asked for — Android, Windows and Apple — each written against its own toolkit rather than wrapped in a browser.
Identity and single sign-on, resource planning, customer management, mail, chat, meetings, file storage, attendance and payroll: multi-tenant services with per-organisation isolation enforced in the database itself.
Production web estates kept as reviewable source — server-rendered sites, custom plugins, build pipelines, and the deployment paths that put them live.
Two-sided marketplaces with escrowed milestones, wallets and commission tiers, identity verification, and a course platform with DRM-protected offline video.
Motion-control firmware on STM32, a CAM path from mesh to G-code, machine platform design, in-house electronics kept as reviewable text, and telemetry coming back off the boards.
A dial-out control plane that survives the loss of inbound SSH, a WireGuard VPN, mail-server infrastructure, per-site authentication, and the runbooks that make recovery a procedure rather than a memory.
Documents, spreadsheets, slides, PDF, forms, notes, whiteboard and diagrams: one engine core behind web and native shells, with real-time collaborative editing.
Industrial chiller design against real thermodynamic property data, GPU capability analysis with offline fine-tuning, and a parametric design platform that signs the provenance of everything it generates.
Self-hosted language models with per-tenant retrieval so nothing leaves the tenant, an on-device inference client, and a testing console driven by an agent rather than a script.
A multiplayer 3D world with server-authoritative state and delta-compressed networking, and 3D-print commerce built on the same rendering stack.
Vector map services, geospatial processing tools, and native mapping clients with offline tiles and turn-by-turn navigation.
Alongside them, in markup, styling, shell and build files: HTML (75) · CSS (57) · Shell (35) · CMake (23) · PowerShell (18) · Inno Setup (10) · Batchfile (6) · Assembly (4) · SCSS (3).
Figures are read from a private Postgres inventory refreshed from the source control API — repository names and descriptions never leave it. Inventory last refreshed 2026-09-17 10:27 UTC.