FixIt

An Expo / React Native + NestJS + Go marketplace — recognise a problem from a photo, live tracking, in-app payments. Its in-product AI layer ships with real operational controls (budget, concurrency, idempotency, cost-tracking) and a Codex-pool gateway, on a multi-runner test pyramid (Playwright + Appium + unit/integration).

The problem

A services marketplace lives or dies on trust at the moment a stranger comes to your door. The hard part isn't the listing page — it's the loop between "here's my broken thing" and "someone is on the way, and I know what it will cost."

I built FixIt around that loop. A customer photographs a problem, the in-product AI turns the photo into a structured job, a tradesperson accepts it, and both sides watch each other on a live map until the work is paid for. Each of those steps is a different system with a different failure mode — recognition, geo-matching, real-time transport, payments — and they all have to agree.

The honest constraint behind it: this is my own product under LEFTEQ, and an AI feature inside a live product can quietly become the most expensive line in the company. So from the first commit the AI wasn't a demo bolted to the side — it shipped with the same operational discipline as payments.

The build

FixIt runs as a tri-stack monorepo: an Expo/React Native app for both the customer and the tradesperson, a NestJS API, and a Go status-service (go-chi) that owns the real-time state nobody can afford to lose. Many apps and shared packages sit behind one type-checked boundary.

The real-time half is geospatial: PostGIS with H3 cells for matching jobs to nearby tradespeople, and a WebSocket channel pushing live position onto the map. Payments run through Stripe and Comgate, so a job moves from photo to paid without ever leaving the app.

I don't trust a marketplace I can't regression-test, so the test pyramid is multi-runner by design — Playwright driving the web surfaces, Appium driving the native app, and unit/integration specs co-located with the code. It runs on a self-hosted CI runner fleet so the mobile and load tiers execute on hardware I control, with k6 covering the concurrency end.

The AI layer

The in-product AI is the part I'm proudest of, because it's boring in exactly the right places. Before any model call, three guards run: a per-tenant budget guard that refuses work once a spend ceiling is hit, a concurrency guard that bounds how many calls run at once, and an idempotency guard so a retried request never pays twice for the same answer.

Every call then lands in a dedicated cost-tracking module — hourly rollups plus a third-party-cost ledger — so the LLM spend is a first-class, queryable number rather than a surprise on the provider invoice. Each of these services has its own co-located spec; the controls are tested like the product feature they are.

Fronting the model providers is a separate gateway microservice: a self-made Codex account-pool, so capacity and credentials live behind one boundary instead of being smeared across the API. The result is an AI layer with the same governance I'd put on money movement — budget, limits, idempotency, an audit trail — which is exactly why it can sit inside a live product at fixit.app instead of in a sandbox.