I build and design systems end to end.

The problem: reports took ~30s and froze the browser while dozens of data jobs ran one after another.

What I built: an event-driven service that runs the jobs in parallel across isolated workers and streams results to the page as each one finishes, with crash-safe checkpoints so a run resumes where it left off instead of restarting. Load time dropped from ~30s to under 5s, with 80–90% smaller payloads.

The problem: migrate live billing from per-user to per-workspace pricing with add-ons, without dropping or double-charging a single customer.

What I built: the new billing platform end to end — per-workspace subscriptions, capacity add-ons, and an admin console to grant free access and issue credits. The hard part was correctness under load: atomic Postgres locks make concurrent charges and capacity checks race-free, and three independent recovery layers ensure every payment is recorded exactly once.

The problem: supporting many ad platforms across many report types meant rebuilding the same screens over and over, and a fix on one being forgotten on the rest.

What I built: a plugin system where each report page is written once and every platform plugs in a small handler that declares what it supports through capability flags. Adding a platform is a new folder, not a rewrite, collapsing what would have been N×M pages into one shared set of components.

The problem: advertisers quietly waste budget on “fatigued” ads that have passed their peak, but spotting which ones — and how much is being wasted — means reading each ad’s daily performance curve by hand.

What I built: an algorithm that finds them automatically. It scans active ads against account-wide baselines to flag suspects cheaply, then runs a time-series fatigue-curve analysis on each one — detecting the performance peak and measuring the post-peak decay to estimate wasted spend in euros — and ranks what to pause, with a validation pass that strips out false positives. Validated on real customer data and pitched to leadership.

The problem: before ad creatives can be auto-tagged by AI, thousands of Meta images and videos have to be fetched and normalized into one consistent, AI-ready format at scale — without redoing work or falling over on flaky source APIs.

What I built: the media-ingestion pipeline that feeds the tagging AI. A three-stage producer/worker ETL on a Redis-backed queue: it resolves each asset’s real source URL from Meta, normalizes it on a GPU (a resized JPEG for images, an 8×8 frame mosaic for videos), uploads the result to the CDN, and marks each row ready for the tagging model to consume.

The problem: a US real-estate firm was routing leads from cold-callers to agents by hand, with no fair distribution and no visibility into which agents actually converted.

What I built: a CRM that captures leads and hands them to agents automatically — round-robin via Sideqik so the load is even — classifies each lead’s status as it moves through the funnel, and scores agents on performance.

A QA tool for call centres that does more than score calls after the fact: it transcribes a live call and separates speakers in real time, then coaches the agent during the call with live hints while scoring them against a custom rubric. Transcription and diarization run locally (whisper.cpp, pyannote); the scoring and coaching layer was benchmarked across local and cloud models (Ollama llama3.1, OpenAI, Gemini). Co-built with my partner to prove the concept, not for commercial use.

An MCP server that lets AI assistants (Claude, ChatGPT, Cursor) query live French job-market data — listings, salary benchmarks, and hiring trends — through the standard tool-use interface they already speak. Deployed on Cloudflare Workers, not yet public. It's the same tool-use pattern enterprise AI copilots are built on.

A browser arcade of quick brain games for developers — a code-typing sprint, a memory grid, a colour match — with a global leaderboard. Shipped solo from idea to live domain in a weekend; two organic posts, zero ad spend, 200+ players across 16 countries.

The problem: routine coding tasks — small features, fixes — eat focus time, but handing them to an AI blindly means unreviewed code and runaway cost.

What I built: an autonomous pipeline that takes a task from Notion and orchestrates specialized agents to plan it, implement it on a branch, run the tests, and review the diff — then opens a merge request for me to approve. Each phase runs in an isolated context to stay cheap and avoid quality loss, with a live cost budget and a human approval gate before anything is pushed.