Skip to content
03 Case studies

Systems I have designed, built and operated.

Anonymised write-ups. No client names, no invented figures. The architecture, the decisions behind it, and what each system does today.

Architecture 5 stages
01 Internal tools
02 API gateway
03 Task router
04 Model pool
05 GPU nodes

Challenge

Internal tools needed dependable language-model capacity. Third-party APIs meant handing over internal data, accepting variable latency, and paying per token for workloads that ran constantly.

Architecture

Several high-memory GPU servers host a pool of quantized models behind one OpenAI-compatible gateway, so every tool integrates once and never learns about the hardware. A router sends each request to the model suited to it, a queue bounds concurrency per node, and a hosted API stays configured as a fallback.

Technical decisions

Quantization was set per model against measured VRAM headroom rather than applied uniformly, because over-quantizing a reasoning model degrades output in ways that are expensive to debug downstream. Context length was derived from concurrency targets, since both compete for the same memory. A small fast model handles classification, so cheap work never occupies expensive capacity.

Outcome

Internal tools call one endpoint and get whichever model fits the task. Capacity grows by adding a node, and the data stays on infrastructure that is directly controlled.

Architecture 5 stages
01 Live ingest
02 Audio + frames
03 STT / OCR / vision
04 Event detection
05 Operator feed

Challenge

A live broadcast carries more information than an operator can track. The work was to understand it while it was still happening, without ever putting the live signal at risk.

Architecture

Video is split on ingest: one path continues untouched to recording and distribution, the other feeds analysis. Audio streams into speech-to-text, sampled frames run OCR and a vision model, and a detection layer turns those signals into timestamped events pushed over WebSockets to an operator dashboard.

Technical decisions

Frames are sampled rather than processed exhaustively, since full-rate vision inference buys accuracy nobody can act on. The language model sits off the critical path: detection stays deterministic and fast, enrichment arrives a moment later. Every queue is bounded with an explicit drop policy, so under pressure the system sheds analysis rather than backing up into the live feed.

Outcome

Operators read a structured, timestamped feed instead of trying to catch everything by eye, and automated responses fire inside the live window.

Architecture 5 stages
01 Encoder
02 Local relay
03 WAN failover
04 Destinations
05 Local recording

Challenge

One production needed to reach several destinations at once. Encoding per destination wastes capacity, and a single uplink makes the venue connection a single point of failure for the whole broadcast.

Architecture

One encoded output goes to a local media server that relays to each destination independently. Egress runs over dual-WAN with automatic failover, and a local recording is written continuously as the authoritative copy, independent of any network condition.

Technical decisions

Relaying locally rather than encoding per destination keeps CPU and uplink cost flat as destinations are added. Local recording is deliberately decoupled: if every network path fails, the material still exists. Reconnection uses backoff, because an outage plus aggressive retries produces a storm that hurts the healthy paths too. Failover was tested by physically pulling connections, not assumed from configuration.

Outcome

One operator publishes to several destinations at once. A failed connection or destination degrades the broadcast instead of ending it, and the local recording survives regardless.

Architecture 5 stages
01 Task queue
02 Planner
03 Executor
04 Verifier
05 Recovery

Challenge

Recurring workflows ran across web interfaces with no programmatic access. Done manually they consumed hours and varied every time. Naive scripting broke constantly, and worse, broke silently.

Architecture

An orchestrator pulls tasks from a queue and hands each to specialised agents. A planner decomposes it, an executor drives a Playwright session with stored authentication state, a verifier independently re-reads the resulting state, and a recovery agent retries or escalates. Every run is recorded step by step for audit.

Technical decisions

Deterministic selectors do the work wherever possible and the model is reserved for planning, because a model asked to click buttons fails in ways that are hard to reproduce. The verifier is a separate agent that re-reads state rather than trusting the report from the executor, since self-reported success is the most common source of silent failure. Steps are idempotent, so a retry cannot double-apply an action.

Outcome

Recurring work runs unattended and verifies itself. Failures surface as actionable alerts with the full run history attached, instead of quietly producing nothing.

Architecture 5 stages
01 React dashboard
02 REST + WebSocket
03 FastAPI services
04 Workers & queue
05 Infrastructure

Challenge

The infrastructure was powerful and unusable by anyone except the person who built it. Every routine action meant an SSH session, which made one person a bottleneck for daily operations.

Architecture

A FastAPI backend exposes a task-oriented API with authentication and roles. A React and TypeScript frontend provides dashboards for GPU status, stream health and automation runs, with live state pushed over WebSockets. Long work runs on background workers with progress streamed back, and every state-changing action is audited.

Technical decisions

The database is the single source of truth and the UI subscribes to changes, because real-time interfaces built on polling drift out of sync exactly when it matters. Anything slow became a background job with visible progress. The interface is deliberately honest about failure: a degraded backend shows as degraded, because a dashboard that hides problems is worse than no dashboard.

Outcome

Operators run production infrastructure through a browser, with permissions and an audit trail. Routine work no longer requires the person who built the system.

Got something that needs building?

Tell me the problem. I will tell you honestly whether I am the right person for it.

Start a project