JONATHAN ANDERSON

Full-stack engineer, mostly TypeScript and React with Node and Python behind it. I usually end up as the only engineer on a system — schema, infrastructure, and the interface a non-technical person actually touches — and most of what I build is for people who don't build software: a care operator reading her own analytics, a clinic's front desk, an invoicing team correcting its own invoices. Healthcare and regulated work is where most of the last two years has gone. Everything below is the long version; the one-page cut is available on request.

Experience

Document intelligence platform — sole engineer, ~580 commits

• Retrieval. Vector search with reranking. Found the reranker was a no-op — a softmax over a single logit always returns 1 — after it had run for months without ever erroring, with every test green. Cut retrieved context from twelve chunks to eight afterwards: better answers, lower cost. HNSW recall tests.
• Ingestion. Excel (a multi-sheet workbook is one document, not one per sheet), PowerPoint parsed per slide, PDF. Fixed an upload limit that was refusing five ordinary documents.
• Classification. AI-discovered labels mapped onto themed document types; replaced regex label-matching by letting the model pick the bucket; category reconsideration rather than stacking priors; per-tenant real categories instead of eight fixed themes.
• Chat. Reports disagreements between documents instead of picking a side. Streaming is SSE end to end and hand-rolled — a Fastify route hijacks the reply and writes text/event-stream itself, the client reads it with a reader and a TextDecoder. Renders markdown, and draws charts from figure tables in answers.
• A canvas map of how a customer's documents relate: my own requestAnimationFrame loop, a camera whose wheel zoom is anchored to the cursor rather than the centre, drag pan, hit-testing in world space, labels fading in past a zoom threshold. No graph library.
• An acceptance harness that scores answers against known-answer fixtures, not just whether documents were filed correctly. A review queue surfaces the documents the classifier wasn't confident about.
• Infrastructure. AWS Bedrock, ECS, RDS and KMS in Terraform; a local dev stack that runs the real pipeline with no AWS at all; CI that runs the tests before anything reaches the customer; auto-deploy on push.
• Worked directly with the client. Several commits are fixes from his own user tests, and the test fixtures were generated to cover his failure list.

Care-facility operations platform — team of five, ~460 commits mine

• Analytics module, ported and rebuilt: TanStack Query hooks, session clustering, inferred time-on-screen, per-user views, thresholds and drilldowns, entity-name resolution so a row says the person rather than an id, a centralised chart palette, and insights that name who rather than drawing a chart and leaving the reading to the operator.
• COO-level features: read-only visit detail with a calendar and facility drilldown, and a people-usage PDF report.
• An LLM help assistant with a get_my_data tool that derives its figures from the same source as the dashboard, so the bot and the UI can't disagree; a session-activity summary attached to support tickets.
• Access control: region-less regional managers denied, rollup counts reconciled, operator access to analytics under prod self-auth.
• Disaster recovery: backup-restore drills end to end, tolerant SSH keyscan, a Supabase restore environment, and a runbook pointing at the team vault rather than at me.
• Email gating on plan-reviewed state; a cohort launch runbook with a scoped test-data reset.

Clinical front-desk oversight — two-person repo, most of it mine

• Crisis safety. The service refuses to boot on an undialable escalation number. A crisis rings and texts, so one dead channel isn't a missed patient. A safety tool that throws speaks the crisis line rather than "we'll follow up". Crisis carve-out in the bounded tool retries; consent opener.
• Two AI voice agents made auditable behind a tool registry. Retell integration with a --base-url flag, so a new tunnel is one command rather than 21 hand-edits; three silent-failure vendor behaviours documented rather than worked around quietly.
• Billing, about 3,600 lines: the invoice lifecycle end to end against Stripe — create, finalise, send, void, refund — reconciled from webhooks; agent tools that issue an invoice and dispatch a payment link; hand-adjustment of unpaid invoices, fees and discounts. No promises of texts the patient won't actually get.
• The no-PHI chokepoint. Every Stripe-bound payload is assembled in one place, whitelisting the allowed fields rather than redacting the bad ones — a whitelist fails closed, a redaction list leaks the next column somebody forgets. Stripe sits deliberately outside the product's BAA.
• Correctness: the schedule and every spoken time use the practice's timezone, not the server's and not the reader's.
• Security review remediation: open redirect, prod webhook secret, sentinel guards, deploy rollback, supply-chain review, a backup window that conflicted with RDS.
• Front end: a month-at-a-glance schedule, a profile-beside-chat panel, a first-login error screen, and iOS/WebKit sticky-header compositing fixes that took three attempts before I stopped mitigating and moved the header out of the scroller.

• Coached a technology founder across six sessions in the run-up to launching his product.

• React, TypeScript and Node on a data-heavy platform. Built the "Secondary Mods" module — the deal-maker for one client and a retention factor for several others.
• Reduced friction in the spreadsheet upload flow, lifting uploads across the client base by 5% and moving several customers into a higher usage tier. It was my idea rather than a ticket.
• Where I learned that doing good work and being indispensable are not the same thing.

• Recovered roughly £200k the business had earned and never billed, by building a correction tool the non-technical invoicing team could run themselves — without touching the underlying charge-point data. Python, Redis pub/sub.
• Consumer-facing as well as internal: the platform served drivers, charge-point owners and Evolt's own admins. Pay-as-you-go drivers couldn't claim charging back because only monthly-tier customers got an invoice, so I built a per-session receipt and styled it to look like a real printed receipt — something you hand an employer to reclaim money should look like the thing it stands in for.
• Full-stack support system: Next.js front end, Python back end, Redis pub/sub for concurrent submissions, automatic ticket IDs, confirmation email.
• Integrated both GraphQL (Apollo/Hasura) and a Python REST API into the front end; FAQ section with admin CRUD.

• Owned end-to-end features in DIANA, the SaaS above a vertical farm's growing units — upstream of the hardware rather than on it. Worked across five developers, three QA testers, product and UX, plus an embedded-systems team.
• Led the JavaScript-to-TypeScript migration, halving the code I touched, and raised front-end test coverage from 5% to 30%.
• Standardised forms on Zod and React Hook Form, cutting the build time for a new form by about 20%. History-tracker feature. Code review, pairing, interviewing and onboarding.

• Ran a floor team. Real responsibility for other people's output under time pressure, which is where I last had to tell someone their work wasn't good enough.

How I work

• Agentic coding, and why I'm strict about it. Claude Code writes most of my code and has for months — ten to fifteen terminals across three or four projects. It only works because I'm not reading every diff, so the work moved to the two ends: scope the change and say what done means before anything runs, then read the risky diffs. Anything I correct twice becomes that project's conventions file.
• What made me strict is the reranker above. It ran for months, never errored, did nothing, and every test was green. Now I ask what a thing would look like if it were silently doing nothing, and test for that.
• Say what it actually is. A dashboard refresh of mine is twenty-second polling, and I'd call it polling — written behind a seam so no call site changes the day it becomes SSE.

Built for myself, for friends, and to solve my own problems

Tools

TypeScript · React 19 · Next.js · Vite · TanStack Query · Tailwind / Radix · Node / Fastify · Python · Postgres / SQL · Supabase · AWS (Bedrock, ECS, RDS, KMS, Backup) · Terraform · Cloudflare Workers / D1 / Pages · Fly.io · Docker · GraphQL (Apollo/Hasura) · Redis · Stripe · Vitest / Jest / Cypress · CI/CD · SwiftUI · RAG and LLM tooling · Claude Code, Codex.

Straight about the gaps: the real-time I've shipped is SSE at both ends, hand-written — WebSockets, Kafka and MQTT I haven't shipped. Python is real; FastAPI isn't.

Education

• BrainStation — software engineering bootcamp. It cost £6,000 and led to a £32,000 role, which is most of what I'd say for it: the return was getting onto the ladder, not the syllabus. Most of what it taught is obsolete now.