Build an expertise routing graph for an organisation — a workflow that answers "who should I ask about X?" from evidence in real work artifacts (questions people resolved in chat, code they reviewed, docs they authored, incidents they handled, tickets they closed, teaching sessions they hosted) instead of a self-reported skills matrix that goes stale immediately. Every recommendation must carry receipts: a plain description of what a person actually did, when, and a deep link to the source. The result is a short list of people to ask (2–3 max, no ranking), and it should stay silent rather than nominate someone on a weak signal. Design it index-first. Ingestion runs on a schedule and writes everything into one internal index; live sources are never queried at question time. Support a fully synthetic mode from day one so the crediting logic and safeguards can be validated safely, then let each ingestion path try a live connector first and fall back to seeded data when a connector is missing or returns nothing — so the demo always works. Ingestion (scheduled, also runnable manually for the first backfill): A seed step that builds a synthetic org, the raw artifacts each source would return, and an opt-in "sources in scope" registry — nothing gets indexed unless it's listed and enabled there. A scheduler on a cron that fans out to one ingestion step per source. Each step is bounded and resumable (process a chunk, save a cursor, continue next run) and writes to a shared index plus an attribution log. Make crediting conservative and fully transparent: log every candidate — credited or not — with a reason. Credit the resolver in chat (never the asker), the assignee on a ticket (never the reporter), the case owner (never the customer), the incident resolver (not everyone paged), and only genuine teaching-session hosts on calendar (never attendees, never routine meetings). Weight recent activity heavily and decay old signals. A directory-sync step (its own schedule) that maps every source's people to canonical identities by email, so one human is one record across all sources. Asking (HTTP pages + JSON APIs, all authenticated to the space): An Ask page with a single natural-language box that calls an Answer API: expand the topic with an LLM, query the index, then have a strict LLM grader decide whether each candidate genuinely relates to the topic; return evidence cards with a recency indicator, and say so honestly when nobody qualifies. Fall back to rule-based logic if the model call errors. A Profile page showing everything the graph infers about a person, with receipts and a "not me anymore" control per topic (backed by a correction API) that routing respects immediately. An Audit page exposing the attribution ledger — exactly what got credited and why. Storage: use one named volume holding a SQLite index. Mount it exclusive-writer for all ingestion, correction, and directory steps so writes serialize and can't corrupt the file; mount it read-only for the read APIs. Make each pass idempotent with deterministic signal ids, wrap each chunk in a transaction, and put a hard per-request timeout on every live external call so a hung call can never hold the write lock. For connectors, I used these — but treat each as a swappable choice for your stack: chat via Slack (or your team's chat tool), code via GitHub (or your VCS), docs via Notion (or your wiki), incidents via PagerDuty (or your on-call tool), tickets via Jira (or your issue tracker), CRM via Salesforce (or your CRM), calendar via Google Calendar (or your calendar), files via Google Drive (or your document store), directory/identity via Okta (or your IdP), and both LLM calls via Anthropic Claude (or your preferred model provider). Keep all routes authenticated to the space by default, and never post to or modify any external system — ingestion is read-only. Tools used: Slack, GitHub, Notion, PagerDuty, Jira, Salesforce, Google Calendar, Google Drive, Okta, Anthropic Claude (model claude-haiku-4-5), SQLite (bun:sqlite), 3B named volumes, HTTP routes, cron triggers