Jan Sachse

I design dense+sparse hybrid search with RRF fusion — once server-side in Qdrant, once as a single SQL query over pgvector + full-text (CTE, FULL OUTER JOIN, HNSW+GIN indexes), always degrading to sparse-only when the embedding fails.

I build IR eval harnesses (nDCG/MRR/recall, bootstrap CI, ablations, frozen sets) that settle my decisions — from model choice to separating relevance from business logic. A change without a measurement doesn't exist for me.

I wire LLMs into products (receipt OCR, search, content generation) with measurement-driven model choice, a provider-abstraction layer, and graceful degradation to a fallback instead of HTTP 500.

I write complete MCP servers from scratch (low-level SDK, 6+ tools with JSON Schema, STDIO transport) — with the handshake verified end-to-end and an eye for JSON-RPC framing pitfalls.

I design rewrite→retrieve→rerank RAG pipelines with each link measured separately — on hard queries I raised MRR from 0.676 to 0.934 at Recall@10 = 1.000.

I orchestrate multiple AI agents (a sequential architect + N parallel researchers) and tool-use loops that mutate app state — with the token and isolation trade-offs settled.

I built a shopping assistant that verifies requirements (color, size, capacity) BEFORE recommending a product — rejecting e.g. a "White/Black" shoe against a "red" requirement.

I price LLM operations before running them (≈2.6M tokens ≈ $0.05 against a $0.50 cap) and pick models by measured quality-to-price ratio, not by the price list.

I design production prompts that force deterministic, schema-shaped LLM output — from template-as-schema to enums in JSON Schema. I treat a prompt as a contract, not a suggestion.

I design mechanisms for working under the context-window limit — single-call context compression and checkpoint/resume for artifacts that don't fit the window (an 80+ slide deck, auto-stop at ~60%).

I empirically diagnosed three failure modes of a cheap model and hardened it with chain-of-thought, small batches and moving the decision from model to code — accuracy from 5/8 to 8/8.

I designed a prompt contract grounding every fact table in a source (a mandatory Source column, data/assumption tags) — a hallucinated quote is the gravest substantive error in my book.

I integrate under-documented external APIs empirically, against the live system (PSD2/Open Banking, courier OAuth, SEC EDGAR) — with retry/backoff, limit workarounds and revert-to-known-good discipline.

I run formal security self-audits (20 findings, including a race enabling PIN brute-force) and harden apps: recursion-free RLS, PII/GDPR protection, prompt-injection hardening.

I design atomic state control against TOCTOU and replay — conditional atomic updates, partial UNIQUE + transactional RPCs — at the database level, not with locks in code.

I design marketplace payment flows (Stripe Connect, escrow, manual payout + sweeper) and invoicing — with idempotent webhooks and server-side amount calculation against client tampering.

I design solution architecture and justify it in writing (ADRs with alternatives) — from deliberately reducing a stack to its minimum to rolling back "correct" choices when context reveals a simpler, safer path.

I design idempotent ETL pipelines — a 10k-record ingest with retry honoring retry-after, CKAN sync with reprojection, an XBRL/EDGAR parser deriving periods from fact dates — resilient to rate limits and dirty data.

I built my own valuation engines (DCF with WACC/CAPM, multiples, DDM) and metric reconstruction from raw EDGAR data — with canonical values written down as tests before implementation.

Advanced Postgres: RRF rank fusion in a single query (CTE + FULL OUTER JOIN, HNSW+GIN indexes), RLS with SECURITY DEFINER functions, and queries designed around real PostgREST limits.

I build apps on the full Supabase stack — dozens of SQL migrations, RLS + SECURITY DEFINER RPCs, Deno edge functions — with a role model immune to policy recursion.

I build software AI-native (Claude Code: custom skills, hooks, project memory, the /loop loop, multi-agent + worktrees) — steering the AI with architectural decisions and review, not the other way round.

I automate Office document generation at the OOXML level — hand-assembling .docx via altChunk, editing .pptx as raw XML — with accessibility built in as automatic transformations.

I designed my own harness for long autonomous build loops: a planning package + MASTER-PROMPT with the /loop loop baked in, a context budget measured like a statusline and a HANDOFF protocol at ≥55% — works on any repo, long-horizon.

I work spec-first: phased backlogs with a measurable Definition of Done, ADRs with a "why + alternatives" section and work contracts with hard prohibitions — instead of hundreds of unplanned auto-commits.

I build CI/CD pipelines (GitHub Actions: build→rsync→service verification) and cron jobs (Vercel, GitHub Actions with retry/backoff) for production deployments.

I run a GitLab backlog as the source of truth (issues, milestones, a label taxonomy) with my own automatic Capacities→GitLab→mirror sync executed by a headless agent.

I work test-first with canonical values (206 cases written before implementation) and a contract-test generator gating on regression rather than on failure.

I enforce accessibility measurably: axe 0 critical/serious errors in both themes, and document WCAG as automatic OOXML transformations, not a manual checklist.

I build interactive graphics: a vanilla-canvas game (3194 lines, custom bitmap font, delta-time loop), a GLB→react-three-fiber 3D pipeline and 3D maps on MapLibre.

I design readable data visualizations — charts with an S/R-level overlay synced to a table, analytics panels, muted palettes — aware of context and audience.

I run a design system as a token contract (audit/drift/update, token-by-token migration) — a consistent look with no raw values scattered through the code.

I build polished frontends on Next.js App Router (RSC, Server Actions), mobile-first PWAs and components without UI libraries — with secrets kept out of the browser.

I run AI trainings in an organization's training program (prompt engineering, vibecoding, Custom GPTs, agents, MCP) and built a materials production line — with teaching and production standards enforced.

Product Owner with a PSPO II certificate — I run a backlog from scope to delivery: phases with measurable criteria, prioritization, GitLab as the source of truth and AI-native task-flow automation.

I translate clients' real processes (law firms) into software — from a staged offer with a pilot to an invoicing system encoding the client's business rules.