A full AI marketing platform, built by one person

How a brand gets measured across AI engines

For engineers: the services, how one scan fans out across AI engines, and how results settle correctly when some calls fail.

Stack

Backend

NestJSTypeScriptgRPC

Jobs

BullMQRedis

Data

PostgreSQL 17

AI engines

OpenAIAnthropicPerplexityGeminiGoogle AI ModeAI Overviews

Frontend

Next.jsReactTanStack QueryTailwind

Delivery

RailwayStripeVitestPlaywright

Five domains behind two gateways

• AuthAccounts, sessions and login.
• BillingStripe subscriptions, credits and usage metering.
• BrandBrands, competitors and the prompts each brand is tracked on.
• ScanRuns prompts across AI engines and records mentions and citations.
• ContentTurns results into share of voice, insights and suggested actions.
• Web and Admin gatewaysEach has its own OpenAPI contract and calls the domains over gRPC.

One scan, from prompt to dashboard

Each prompt and engine pair is its own job, so one slow or failing engine never blocks the rest.

1. TriggerA five-minute cadence tick, a manual start or a free scan starts a run.
2. Fan-outThe run creates one job for every active prompt times every enabled engine, and records the total.
3. WorkerUp to 10 jobs run at once. Each one asks the engine and stores the full answer.
4. RetryTemporary errors retry up to 3 times with backoff. Bad API keys fail at once, with no wasted retries.
5. ParseBrand and competitor mentions are matched as whole words, and cited URLs are de-duplicated.
6. SettleEach finished job adds to a counter in one atomic update. The last one closes the run.
7. InsightShare of voice and citation trends are recomputed and shown on the dashboard.

Run states

Cancel and natural finish race on the same conditional update, so only one of them wins.

Key decisions

Settling a run, simplified

async onJobFinished(runId: string, ok: boolean) {
  // one atomic update per job: no read-modify-write race between workers
  const run = await sql`
    UPDATE runs SET completed_jobs = completed_jobs + ${ok ? 1 : 0},
                    failed_jobs = failed_jobs + ${ok ? 0 : 1}
    WHERE id = ${runId} RETURNING *`;
  if (run.completed_jobs + run.failed_jobs < run.total_jobs) return;

  const status = run.failed_jobs === 0 ? 'completed'
    : run.completed_jobs === 0 ? 'failed' : 'partial';
  // CAS: only close a run that is still running (cancel may have won)
  const won = await sql`
    UPDATE runs SET status = ${status} WHERE id = ${runId} AND status = 'running'`;
  if (won.count === 1) await insights.recompute(run.brand_id);
}

Scale

Reliability and operations

• Gates on every changeTypecheck, lint, convention checks, tests, build and contract checks run before anything reaches main.
• Real-stack testsIntegration tests run against real PostgreSQL and Redis. Mocks never count as proof.
• Browser acceptancePlaywright runs real user flows in a browser before a feature is accepted.
• Release readbackEvery deploy exposes its commit and build, so what is live is always known.