Fleet operations

One console operating six of the seven live demo backends.

The demos are not seven isolated screenshots. They run as a small fleet: shared registry, public repos, CI, drift checks, Cloudflare Pages Functions, and browser-run health probes. The button below fires one request at each backend from your browser, then prints the status, latency, and actual result line. If a backend is down, this page says so. The seventh backend — the RevOps Software Factory — is deliberately not health-pinged from here: its multi-agent run makes real model calls behind a cache and budget guard, so you exercise it from its own demo page, which prints a live token-cost ledger.

What this proves

backend coverage

Every flagship demo has a Pages Function behind it, and this console exercises each one with a minimal meaningful request.

failure visibility

The checks are designed to expose real failure classes: orphaned contracts, unsafe ops code, failed tool calls, weak funnel config, harvestable answers, and DNS policy state.

ship discipline

The same registry, test gates, visual snapshots, public repos, and freshness checks keep the storefront and clone-and-run repos from drifting apart.

Live backend check

Idle — no requests sent yet.

  1. Q2See POST /demos/q2see/analyze

    probe sends a 1-row CRM export: executed contract, no invoice

    proves quote-to-cash inspection still reaches the server analyzer and returns a real finding class

    Exact CSV schema — copy/paste this to reproduce the finding 
    opportunity_id,account,stage,arr,quote_id,quote_status,quote_amount,quote_currency,contract_id,contract_status,contract_executed_at,term_start,term_end,invoice_id
OPP-PROBE,Ops Probe Co,Closed Won,48000,Q-PROBE,Accepted,48000,USD,C-PROBE,Executed,2026-05-01,2026-05-01,2027-05-01,

    —

  2. Apexlint POST /demos/apexlint/lint

    probe sends a 5-line Apex class with DML inside a loop

    proves ops-code linting still catches a deterministic Salesforce governor-limit risk

    —

  3. Tracewell POST /demos/tracewell/analyze

    probe sends a 1-run agent trace with a failed tool step

    proves agent-run observability still classifies failed tool behavior instead of flattering the trace

    —

  4. Funnelguard POST /demos/funnelguard/check

    probe sends a minimal valid FunnelConfig

    proves the lifecycle-rule engine is reachable and can evaluate a structured funnel config

    —

  5. Forager POST /demos/forager/ingest

    probe sends a 2-message Slack thread: question + resolved answer

    proves knowledge-harvesting logic still extracts an answer from a realistic support-thread shape

    —

  6. Inboxward GET /demos/inboxward/inspect

    probe sends a live DNS lookup for example.com

    proves the fleet includes one public-internet probe and labels its external boundary

    —

How a demo ships

The fleet is run like production software, not like screenshots. Each gate below is real, repeatable, and tied to a specific failure it prevents.

  1. brief One-paragraph product brief into demo-forge, the private generation pipeline. This keeps demo intent explicit before code exists.
  2. registry One canonical registry.json drives this hub, the portfolio's demo cards, and every cross-link. Zod validation catches malformed proof claims; the portfolio's copy is byte-compared on every build and fails on drift.
  3. gates Type check (astro check), backend unit tests (node --test), structure checks, and Playwright visual regression — every demo snapshotted full-page at 320 / 768 / 1440 against committed baselines.
  4. deploy Static build + Pages Functions deployed to Cloudflare Pages. The backends you pinged above are those functions, not mocked client-side fixtures.
  5. sync Each demo also ships as a public clone-and-run repo with its own CI. A freshness drift check fails when a public repo falls behind the deployed source, so proof links do not quietly go stale.

The judgment, not just the uptime

Operations proves the fleet is real and run with discipline. The harder question — whether the design reflects production judgment, not just a working demo — is answered in the architecture writing. Three decisions recur across the work:

  1. the gate stands without the model Safety and quality gates are deterministic, so they hold when the LLM is wrong, slow, or down. Apexlint catches Salesforce governor-limit risks with rules, not a model — no API key, no inference. The principle, written up: The Gate Has to Stand Without the LLM.
  2. a public endpoint can't run an unbounded bill Where a demo makes real model calls behind a public URL, every request passes a guard — cache hit, then daily-budget check, then per-IP rate limit — and fails back to the last good run rather than erroring or burning money. Written up: I Rebuilt Cloudflare's $1 Review Factory for RevOps.
  3. observability that doesn't flatter the trace A failed step is classified as failed, not smoothed over — Tracewell's probe above proves it labels failed tool behavior honestly. The same discipline drives a re-runnable review panel that treats the last run as the test suite: Your Own Work Is Invisible to You.

The full set of owned systems and case studies is at dallascrilley.com/work.

The fleet, repo by repo