Real projects

Case Studies
Results, not promises

Real AI implementations — concrete projects and concrete numbers straight from the code repos. Clients anonymized, systems real: from proof of concept to production. Results, not promises. No marketing bullshit.

5

AI projects: brand, investigations, medtech, sales, sport

Agentic+RAG

a pattern recurring across builds

80%

enforced test-coverage gate

from repos

every number comes from real code

CASE STUDIES

Projects
that actually ship

AGENTIC + RAG

A global consumer brand

Brand comms team
Proof of concept
Agentic pipeline + RAG
Key result
3+1

auditable verdict classes, each backed by an evidence quote

S

Situation

A global brand's communications team receives hundreds of press articles a month and needs to know which reinforce vs. undermine its strategic messaging. Doing it by hand is slow, subjective, and impossible to audit — and naive "does the LLM like it" scoring hallucinates verdicts and can't cite why.

T

Task

Build a proof-of-concept agent pipeline that pulls brand coverage from media monitoring on its own, scores each article against the brand's own strategy documents, and produces stakeholder-ready reports with quote-backed verdicts instead of opaque scores.

A

Action

I designed a deterministic, provider-agnostic pipeline (LangGraph) that deliberately separates the LLM's judgement from the scoring, and wrapped it in a production-shaped service with QA gates so every verdict is traceable.

  • A RAG "brand playbook" extractor: a dedicated agent reads the strategy docs (PDF/DOCX) and distills them into 3–7 structured pillars (thesis, keywords, do/don't rules, weights) — that becomes the scoring rubric.
  • Hallucination-proof scoring: the LLM only emits per-pillar relations (support / neutral / contradict), while a pure-Python engine computes the integer index and maps it to the verdict locally — the model never sets the score.
  • A self-correcting QA loop: verbatim-quote verification, label/score consistency, pillar coverage — with one automatic, stricter re-run whenever validation fails.
  • Production shape: a model layer swappable across 3 providers (OpenAI / Anthropic / Google), FastAPI + Celery + Postgres/Redis, encrypted secrets, token-cost tracking, scheduled daily and monthly reports.
R

Result

0

verdicts without an evidence quote

Code

computes the score, not the LLM (no verdict hallucination)

80%

enforced test-coverage gate (71 test files)

3

swappable LLM providers

AI + RAG · INVESTIGATIONS

A digital-forensics studio

Investigation analysts
Frontend + AI UX
RAG + visualizations
Key result
6

types of forensic visualization rendered from LLM output

S

Situation

A digital-forensics studio was drowning in terabytes of mixed device evidence (documents, chats, emails, photos, audio, GPS/tower logs). Analysts sifted through phone data by hand — slow, and impossible to correlate across sources.

T

Task

Design and build the investigator-facing front end: a single per-case workspace — case setup, evidence upload, ingestion tracking, evidence-grounded AI chat with citations, and rich visualizations — decoupled from a backend that was still being built.

A

Action

I built the app as a strictly-typed SPA (React 19 + TS) with a backend-agnostic service layer — so the UI could be developed and demoed against realistic mocks, then flipped to the live API with no code changes.

  • A dual-mode API layer: a switch between mocks (MSW) and the live backend, normalizing snake_case (Django/DRF) into camelCase domain types — UI built independently of backend readiness.
  • Evidence-grounded RAG chat: every AI answer carries inline citations back to the exact source file, plus a "tag citations → generate case report" flow.
  • A pluggable visualization system (registry + renderer) that turns LLM tool outputs into a timeline, map, chart, network graph, heatmap and data preview.
  • A Leaflet geospatial explorer (clustering, dwell-time heatmap, animated route playback, single-visit anomaly layer) synced with the timeline; plus voice input/TTS and chain-of-custody audit logging of interactions.
R

Result

6

forensic visualization types from LLM output

100%

of AI answers cite their source evidence

Dual-mode

mock or live API with no code changes

17

test files (Vitest + RTL, MSW)

LLM DATA PIPELINE

A medical-equipment distributor

Quoting team
Production
LLM + data pipeline
Key result
17-col

one canonical schema from any tender spreadsheet

S

Situation

A medical-equipment distributor receives tender spreadsheets from dozens of sources — each with its own headers, layout, units and format (.xls, .ods). The same concept (quantity, unit price, catalog reference, manufacturer) hides under many different Polish headers. Staff re-keyed every workbook into one internal format by hand — slow and error-prone.

T

Task

Build a pipeline that reliably locates the real data table in any workbook, maps its arbitrary headers onto a canonical schema, normalizes references/units/packaging, and emits a clean styled spreadsheet plus a readable audit trail — runnable by non-technical staff on Windows, without touching code.

A

Action

I built it as a modular package with a clear staged pipeline (detect → map → apply → enrich → repackage), keeping the LLM tightly scoped to the one thing it's good at (semantic header interpretation) and doing everything else deterministically in code.

  • A dependency-free, pure-stdlib XLSX parser with table-detection heuristics (merged headers, ragged rows, in-table subtotals, footers), validated against golden snapshots — fast and reproducible.
  • A strictly-constrained LLM mapping stage: the prompt gets only a header row plus one sample data row and is forced to return JSON with per-column confidence and a choice of 5 actions (copy / regex / analyze / convert / insert).
  • Confidence-based styling: cells below threshold (50/80%) get colour-coded with a Polish reviewer comment (source, target, confidence, rationale) — a human sees exactly what to double-check.
  • Deterministic post-processing: manufacturer enrichment with an audit trail, fuzzy catalog-reference matching (rapidfuzz), leading-zero preservation, packaging recalculation; SQLite LLM cache + cost tracker; packaged as a double-click Windows app.
R

Result

Production

pipeline running at the client

5

configurable column-mapping actions

37

file regression baseline (4 datasets)

2-click

Windows app, no Python install

AGENTIC SALES

A B2B promotional-apparel company

B2B email sales
Research + MVP foundation
Agent + evaluation
Key result
100%

decision-routing accuracy across a 146-thread benchmark

S

Situation

The company sells custom-printed apparel through an online store and a B2B team, quoting over email. Every inquiry means a rep manually reconciling it against a fragmented catalog (~309,000 supplier SKUs across 6 catalogs, no shared schema), complex per-method decoration pricing (screen print, embroidery, DTF — by quantity, area, colors) and a CRM of ~12,800 deals. Only ~6% of the 5,781 email threads were even linked to a deal — context scattered, quoting slow and inconsistent.

T

Task

I was brought in as the AI developer to research the sales operation end-to-end and build the foundation for an autonomous email-sales-agent MVP: structure the CRM and email history, prove what an LLM can reliably extract and quote, and specify the production architecture before build-out.

A

Action

I treated it as a data-and-evaluation problem first: build the pipelines and a rigorous benchmark to de-risk the agent before writing its production core.

  • A data pipeline: sync CRM entities + download and normalize 5,781 email threads, enrich them (subject classification, message labeling, thread-to-deal resolution) and analyze response time, engagement and product trends.
  • An LLM training-data layer under strict JSON schemas with per-call cost budgets — a sales playbook of winning/losing patterns and objection handling.
  • A 146-thread agent benchmark (batched runner + KPI aggregation): decision-mode routing, extraction quality, missing-critical-data detection, AI-vs-CRM price comparability — plus concrete guardrail recommendations.
  • The production spec: a LangGraph state machine (4 → 13 states), MCP tool servers (store / CRM / pricing), a FastAPI layer and human-in-the-loop — on GDPR-compliant, EU-hosted Gemini (Vertex AI); engineering discipline behind an 80% coverage gate.
R

Result

146/146

threads with 0 parse errors (100% routing accuracy)

7.75/10

avg extraction quality (100% missing-critical detection)

~34s

per thread (146 threads in ~15 min)

5781

threads + ~12.8k deals + ~309k SKUs structured

SPATIAL AI / ML

A sports-analytics venture (football)

Spatial analytics
Validation-first R&D
Spatial ML
Key result
> 0.70

hard go/no-go gate before any platform is built

S

Situation

Top clubs buy camera tracking data (all 22 players in motion) — but in the second tiers of Central/Eastern Europe, the Balkans and the Nordics that data isn't sold at any price. Scouts and agencies there only have cheap event data (a log of on-ball actions), leaving them blind to the spatial layer — a gap made worse when a popular free advanced-stats source went dark in early 2026.

T

Task

Design the core ML that reconstructs the missing off-ball spatial picture from cheap event data alone — and, before any platform build, cheaply confirm or kill the central bet: that aggregate spatial metrics estimated from events rank players the same way real tracking does.

A

Action

I ran it as a validation-first engagement: froze a single make-or-break metric, built a runnable evaluation harness around it, and tied every euro of spend to that gate — before any product code existed.

  • Decomposed the model into three layers, only one of which learns: a possession-value layer (xG/xT/VAEP recalibrated per league on open CC-BY data), a deterministic physics layer (pitch control / pressing / line-breaking, zero training data) and a low-parameter role/formation imputer reconstructing ~21 off-ball positions, calibrated on 17 paired matches.
  • An immutable "yardstick" implementing the go/no-go gate: per-player Spearman rank correlation (never per-team — team aggregates hide the per-player error the buyer is paying to avoid), pooled across 17 legally-clean matches, over 4 metrics plus their mean, with a > 0.70 bar.
  • Hardened the evaluator: a leakage guard (a sealed tracking sentinel that raises on any attempt to read ground truth), deterministic seeding and self-checks (oracle = 1.0, guard trips, two runs match), dependencies kept light (numpy + stdlib).
  • An autoresearch "ratchet": three files with strict ownership (immutable yardstick, editable model file, human-authored research directions); each experiment edits one file, is scored against the frozen yardstick and git-kept only on a > 0.005 gain — ~12 experiments/hour; plus a 15-hypothesis falsifiable backlog and a legally-clean data policy baked into the guardrails.
R

Result

> 0.70

go/no-go gate (per-player Spearman) over 17 matches

3 layers

model architecture — only one is learned

~12/h

experiments in the automated ratchet

#1 / 219

idea selected from a structured review

NEXT STEP

Want results
like these?

A 30-minute call. No strings attached. You'll find out whether I have a sensible way to solve your problem.

Book a call See AI consulting → See AI implementations →