Systems I built for a consulting practice, client prototypes and demonstrations, and my independent products. Each example states its scope; prototypes and private products are not presented as enterprise deployment claims.
PRACTICE OPERATIONS / DELIVERED FOR A CONSULTING PRACTICE
Practice problems, turned into services. AI helped build them. Fixed rules run them.
Two services I designed and built for practice leadership. Each reads the system of record and puts the next action in Microsoft Teams.
Practice operations · Rolled out practice-wide · 2026
Late timesheets hold up billing and month-end close. I built a service that works out who still owes a timesheet and reaches each person, then their manager, in Microsoft Teams before the deadline.
RESULTS
Internal measures, reported as observed: ~93% average to 98–99% as soon as it went practice-wide; people missing each deadline fell from ~14 a week to 2–5; official operations score hit 100% in the first full week.
Won work with nobody named puts start dates, revenue and utilization at risk. I built this service so practice leadership sees those deals every weekday morning, 2 to 10 weeks before work starts, with who to contact.
HOW IT OPERATES
Every weekday morning: a digest in Microsoft Teams. 2 to 10 weeks: the look-ahead on won deals that still need people named, including roles that call for AI skills. One case per deal: who to contact, what changed and an audit trail.
Draw an area on a map of federal land or just ask in plain English, and get land status, legal description, stipulations, and permit readiness back in about four seconds. The same answer takes an analyst thirty minutes across three disconnected systems.
Draw an area, get an answer
One polygon, eight authoritative federal layers, ~4 seconds. Land status, managing agency, responsible field office, PLSS legal description, stipulation triggers, setback encroachment, and NEPA pathway, with the agent narrating the same result in the chat. The footer reports what it queried and how long it took.
THE DECISION BEHIND THE SYSTEM
A versioned, bidirectional map ↔ agent contract
The integration contract is the architectural value. A typed event vocabulary (zoomTo, goToLegal, highlightFeature, setLayer, generateReport) is carried in both directions with a contract version stamped on every payload, backed by eight schema-validated agent topics and a lockstep bump rule. If the published agent drifts from the app, the app logs a warning on every event rather than failing silently. The check addresses a failure I encountered when a renamed event passed CI against a mock but did not match the published agent.
Architecture, scope & additional evidenceExplore the technical decisions and product screenshotsShow detailsHide details
An analyst asking "can we drill here?" burns half an hour bouncing between a permitting system, a desktop GIS, and a stack of PDFs. I built a map where you draw a polygon or just ask, and an agent answers from eight authoritative federal layers in under four seconds. The hard part wasn't the AI. The previous version put the chat in a cross-origin iframe next to the map, which means the browser's same-origin policy made it structurally impossible for them to talk; the shipped workaround literally copied a prompt to the clipboard for the user to paste. That was an architecture bug, not a skill gap, and no better model would have coded around it. I rebuilt it as one page, one JavaScript scope, with a versioned two-way event contract between the map and the agent. Draw → agent. Agent → map. Both directions, no clipboard.
How the system works
Draw a polygon or ask in plain English
8 authoritative federal layers queried in parallel
One page, one JavaScript scope. Bot Framework Web Chat is self-hosted in-page and connected to the agent through the M365 Agents SDK with MSAL authorization-code + PKCE sign-in: the anonymous-only transport was evaluated and rejected on that basis. Agent→map runs over backchannel event activities against a versioned vocabulary; map→agent sends the drawn geometry plus a computed intersect summary. A three-tier intent router resolves map commands locally with zero model calls, falls through to a built-in mock for offline development and CI, and reaches the real agent for anything conversational, with an explicit rule that a question merely mentioning a legal description must reach the agent rather than being swallowed by a local fly-to. Analysis fans out across eight federal feature services in parallel with per-layer caps and timeouts, resolving land status, managing agency, field office, PLSS legal description, split-estate signal, setback encroachment, and NEPA pathway. Regulatory claims cite their source or abstain; geospatial facts deliberately don't cite, because they're tool outputs rather than regulatory assertions. Ships QA-first through Vercel with a manual-dispatch promotion gate to Azure Static Web Apps and post-deploy smoke tests in the same job.
Technology
Copilot Studio (generative orchestration)
GPT-4.1
M365 Agents SDK
Bot Framework Web Chat
MSAL / OAuth PKCE
Leaflet + esri-leaflet
ArcGIS Maps SDK
Turf.js (geodesic geometry)
Power Automate
Playwright
Vercel + Azure Static Web Apps
Scope
~3,600 lines of application code across 24 modules with ~2,100 lines of test code: 125 unit and contract assertions plus 12 end-to-end suites across both map engines. Eight schema-validated agent topics, a versioned two-way event contract, and an intent evaluation set wired into CI. Measured in-app: 8 authoritative layers resolved in ~4 seconds against a ~30-minute manual baseline. Largest single analysis observed spanned 11.7 million acres, 1,434 federal and 964 mineral-agreement features, 614+ survey parcels, and 10 field offices. Built solo in about two and a half weeks. I architected, built, tested, and shipped all of it.
"I don't know" never silently becomes "no"
A layer query that errored returns a count of zero, but the signal is unknown, not none, and reporting it as none is a false negative on a permitting decision. A truncated result page filtered to zero isn't an authoritative zero either: the server only sent the first N matches and real overlaps may exist on pages nobody saw. Both are treated as indeterminate and surfaced as such. For a tool feeding a federal decision, that's the line between decision support and liability.
Original cost research that changed the economics
I pulled per-agent consumed-versus-billed telemetry and proved the authenticated SDK channel is zero-rated for licensed users: 145 credits consumed, zero billed. The legacy anonymous iframe agent metered 91 and billed all 91. Same product, same work, one architecture decision separating a real per-turn bill from nothing. Vendor documentation contradicted itself on this; the meter didn't.
Real geospatial correctness, not a map library demo
Acreage is geodesic on the WGS84 sphere, deliberately not Web Mercator. The surface-location point uses a true point-on-feature, not a bounding-box midpoint. For an L-shaped or curved corridor the bbox center can land outside the drawn footprint, and the form must never claim coordinates the operator didn't draw. Parcels that merely touch the boundary are separated from real overlaps, so the headline count means what a land specialist thinks it means.
Speaks the customer's language: PLSS legal descriptions
Converts cadastral survey records into correctly formatted legal descriptions such as "NW¼ SE¼ Sec. 14, T. 6 S., R. 96 W., 6th P.M.", handling aliquots, government lots, and unsurveyed tracts, and rolling up to a section-level description of the whole area rather than presenting one arbitrary aliquot as the answer. It runs in reverse too: type a township and range, and the map flies there and analyzes it.
Split-estate triage with honest uncertainty
Federal minerals under non-federal surface is the single most consequential land-status fact in a drilling permit. An undetermined ownership code is treated as unknown rather than non-federal, so an indeterminate record can't produce a false split-estate positive. When the mineral query fails, the tool surfaces the uncertainty instead of claiming no federal interest. Cited to the governing regulations and labeled illustrative throughout: it's a pre-check, not a title determination.
Runtime engine swap: Leaflet ⇄ ArcGIS, one URL parameter
Both map engines sit behind a single factory with a per-load override, deliberately runtime rather than a build flag so the end-to-end suite validates both. Layer endpoints are entirely config-driven. Swap the public federal services for on-premises enterprise GIS endpoints behind a firewall without touching application code. Stateless: no database, no vector store, live queries against authoritative sources.
Portability as a design stance
Every edge swaps: the agent platform for any agent SDK, one mapping stack for the other. The custom middle is the value: the event contract, the layer configuration, the guardrails, the evaluation harness. Tools built MCP-first rather than bound to a single vendor's flow runtime make that architecture portable across platforms. That's a deliberate architectural hedge, made while the platform was still convenient.
This is the half that was structurally impossible before. "Zoom to Colorado." "Hide the federal lands layer." The agent emits typed backchannel events and the map obeys: same page, same JavaScript scope, no clipboard, no iframe boundary.Eight to twelve service calls fan out in parallel. The overlay reports what's resolving rather than hiding the work behind an indeterminate spinner. Any layer that errors or truncates is carried forward as indeterminate, never as zero.The 13-point surface-use plan assessed point by point, a deficiency checklist to fix before filing, and the spatially derivable form fields pre-filled: each with a provenance column naming where the value came from. Every field the tool can't know is explicitly marked operator to complete rather than quietly guessed.Draw an access route and it buffers into a construction corridor, then runs the same full analysis along it: geodesic throughout, because a corridor's true area and the features it crosses are the whole question for an access road.Identical analysis running on the ArcGIS Maps SDK instead of Leaflet: a runtime swap behind one factory, not a rebuild. The end-to-end suite validates both engines, so neither becomes the one nobody tests.
An agentic prototype for federal permitting review. It reads each submitted document, normalizes it for every reviewer, flags risk against their rules and drafts a preliminary assessment before a person opens the record. Its conversational GIS agent became the seed of GeoPAL.
Architecture, scope & additional evidenceExplore the technical decisions and product screenshotsShow detailsHide details
THE DECISION BEHIND THE SYSTEM
Reviewer-grade normalization
Submitters write packets however they write them. Reviewers want consistency. The AI analyst reads every document and produces the exact review structure each role expects: consistent section order, extracted fields, and risk flags. One source packet, N normalized views.
A single application packet at DOI's Bureau of Land Management moves through parallel subject-matter reviewers (geologists, engineers, adjudicators, and land-use experts), each wanting the same information, formatted the same way, every time. But submitters write packets differently: different structure, different terminology, different completeness. I built a working agentic layer that sits above the existing line-of-business system: an AI analyst reads every submitted document, normalizes it into the exact review layout each reviewer expects, flags risks against their rules, and writes a preliminary assessment before any human opens the record. Paired with a conversational intake that meets operators where they are (new, experienced, or just needing a refresher) and a conversational GIS agent that turns natural-language queries into live polygon intersects. Human review remains a deliberate decision point; any expansion of automation requires separate evidence and authorization.
How the system works
Application submitted via Power Pages
AI Builder extracts & normalizes
Power Automate rules engine flags risks
Preliminary assessment written to record
MS Approvals + Adaptive Cards to Teams/Outlook
Approved → PDF decision letter auto-generated
Architecture
Operator → Power Pages intake + Copilot Studio chat (vector-indexed, cited) → Leaflet + Copilot Studio spatial agent → model-driven Power App with custom PCF components for reviewer experience → AI Builder evaluator (extraction, normalization, risk flagging) → preliminary assessment persisted → Power Automate rules engine routes via native MS Approvals + Adaptive Cards in Teams + Outlook → on final approval, Power Automate + PDF connectors auto-generate the agency-templated decision letter and email the applicant. The AI reasoning layer is a standalone HTTPS endpoint that any legacy system can invoke.
Technology
Power Pages
Copilot Studio
AI Builder
Power Apps (Canvas + Model-Driven)
Custom PCF Controls
Power Automate
Native MS Approvals
Adaptive Cards
Leaflet (OGC)
Azure AI
Scope
Power Pages landing with conversational intake · Leaflet map with Copilot Studio spatial agent · Canvas + model-driven Power Apps with custom PCF controls · AI Builder evaluator with preliminary risk assessment · Power Automate rules engine + custom workflows · Native MS Approvals with Teams + Outlook Adaptive Cards · PDF decision-letter generation via connectors. Built as a working proof-of-value for DOI/BLM and demoed live to federal permitting stakeholders.
Agentic preliminary assessment
AI Builder + AI Hub reasoning over the normalized packet flags risks against each reviewer's rule set before a human opens the record. Every finding traces back to its source passage. Reviewers start from an informed position, not a blank page.
Conversational intake for any skill level
Power Pages landing with an embedded Copilot Studio agent, vector-indexed against the agency's own document corpus. Brand-new operator? Guided walk-through. Experienced? Fast refresher. Expert? Direct drill into the regulation. Answers are grounded with source references for reviewer inspection; citations do not remove the need to validate an answer.
Conversational GIS agent: the seed of GeoPAL
A map bound to a conversational agent: draw a polygon, ask "what federal lands and mineral agreements are in this area?", and get a live geospatial intersect back inline. This layer proved the idea and exposed a limitation: the chat lived in a cross-origin iframe, so the map and the agent could never truly talk. Rebuilding that seam properly became its own product. See the GeoPAL deployment above.
Custom PCF components inside the model-driven app
Where native Power Apps controls weren't expressive enough, I built custom PowerApps Component Framework controls in TypeScript: recent-action timelines, reviewer-status visualizations, inline risk-flag surfaces. The app reads as purpose-built, not templated.
Native MS Approvals + Adaptive Cards in Teams & Outlook
Reviewers never have to open the app. Same rich form inside the record, in Teams, and in Outlook: validation, required fields, inline approve/decline. Native Microsoft Approvals underneath for directory-linked routing and an auditable approval history.
Power Automate as the rules engine
Custom-authored Power Automate flows carry the business logic: rule-by-rule evaluation per reviewer role, routing, escalation, parallel and serial chains, PDF decision letters via connectors, applicant notification email. Declarative, visible, governable without touching code.
Modular HTTPS endpoint: decoupled from the stack
The reasoning layer is callable as a plain HTTPS endpoint from any system: legacy .NET, Java, SAP, custom web. Send a document, wait 30 seconds to 3 minutes, get back a structured assessment. The modernization layer sits above what already runs without replacing the existing system.
Live demo · Commercial · March 2026
Inbox-Triggered Autonomous Expense Agent
Photograph a dinner receipt on the plane home, email it, and land to find it extracted, evaluated against company policy, and waiting in your manager's Teams feed with written reasoning. No app, no login, no human in the trigger path.
The input
An off-angle, naturally-lit phone photo of a real dinner receipt: no special capture, no pre-processing. This is what the agent actually has to work with.
THE DECISION BEHIND THE SYSTEM
Inbox is the trigger: the agent runs without you
No login, no portal. Email the receipt from the plane, from dinner, from the ride share: a single email with seven mixed JPEG / PNG / PDF attachments is fine. The agent wakes on arrival, fans out per attachment, extracts, evaluates, and either routes for approval or rejects with a written reason, without a manual intake step.
Architecture, scope & additional evidenceExplore the technical decisions and product screenshotsShow detailsHide details
Everyone hates expense reports. Everyone has to submit them. I built a working autonomous agent that lives on an inbox: snap a photo of a dinner receipt on the plane home, email it to the agent, and by the time you land the system has extracted the line items, evaluated them against the company's plain-English policy document, flagged any violations with written reasoning, routed valid ones to a manager inside Teams, and logged the whole chain to Dataverse. Email starts the workflow without a separate login or manual intake step. Built in under two days as my portion of a live demo to a commercial audience in March 2026. The same pattern applies to invoice validation, contract compliance, and any unstructured-document intake. The agent handles document interpretation within a workflow whose routing and approval rules remain explicit.
How the system works
Photos emailed to agent mailbox
Power Automate fans out per attachment
AI Builder extracts structured line items
Full policy in context (CAG): AI evaluates
Approvals Connector → Adaptive Card in Teams
Approved → Dataverse master + line items
Architecture
Email → Power Automate trigger → per-attachment fan-out → AI Builder extraction call (GPT-4.1-mini) pulls structured line items → AI Builder evaluation call pulls the full SharePoint-hosted policy into context (CAG pattern) and evaluates each line with a reasoning-class model (GPT-4.1 or Claude via Azure AI Foundry) → deterministic routing through Power Automate → native Microsoft Approvals Connector dispatches Adaptive Cards to Teams + Outlook → manager decision writes back to Dataverse in a one-to-many master-expense + line-items schema with AI-written violation reasoning on each line → approved record is portable to any downstream AP system via Power Platform's 1,600+ connectors or a custom one.
Technology
Power Automate
AI Builder
Copilot Studio
Azure AI Foundry (GPT-4.1 · GPT-4.1-mini · Claude)
Dataverse
MS Approvals Connector
Adaptive Cards
SharePoint Online
Microsoft Teams
Outlook
Scope
Email-triggered agent · Multi-model AI pipeline (GPT-4.1-mini for extraction, GPT-4.1 / Claude for policy reasoning) · Cache-augmented generation (CAG) against a SharePoint-hosted policy Word doc · Power Automate orchestration with deterministic guardrails · Dataverse master + line-item relational schema with AI-written violation reasoning · Native MS Approvals Connector with Adaptive Cards across Teams and Outlook. Built in under two days as my portion of a live demo to a commercial audience in March 2026.
Policy-as-data via cache-augmented generation (CAG)
The company policy lives as a plain Word document in SharePoint. At execution, AI Builder pulls the full policy into the model's context: no vector database, no re-indexing, no developer. Upload a new policy; the very next receipt is evaluated against the new rules. This is CAG, not RAG: the AI reasons over the full document in one pass instead of stitching retrieved chunks, which matters because policies have cross-referential rules, such as "rule A applies unless rule B is met", that chunked retrieval can break. Change management becomes editing a Word doc.
Right model for the right job: cost-conscious by design
Multi-stage AI orchestration assigns extraction and policy reasoning to models suited to each task. Model selection balances quality, latency and measured usage. Pricing depends on the provider, deployment and actual token consumption; the case study does not extrapolate a universal cost per receipt.
Per-line-item violation flagging with AI-written reasoning
Not just "rejected." The receipt is decomposed into individual line items, each evaluated separately, and the AI's reasoning is persisted into the row: "Rejected: Old Fashioned and Cabernet Sauvignon violate the no-alcohol clause." Dataverse stores the data in a one-to-many master-expense-to-line-items schema, so every decision is traceable at the line level, not just the receipt level.
Native MS Approvals Connector + Adaptive Cards everywhere
Managers review and approve through Teams or Outlook. The native Microsoft Approvals Connector writes to a single audit trail regardless of surface. Adaptive Cards render the extracted data, the policy verdict, the submitter's context, and the approve/reject controls: one card, no app-switching, no separate AP portal.
Guardrails + deterministic process around a probabilistic core
AI handles the extraction and the reasoning: the parts where language and context matter. Power Automate handles the orchestration, the routing, the state. Policy rules are declarative, written in English, editable by anyone in the business. Manager approval is still a deliberate human step. The agent never autonomously posts to the finance system without a deterministic pre-condition chain validating the outcome. The demonstrated pattern keeps a human approval step inside a deterministic workflow.
Full traceability, Dataverse-backed
Every receipt image, every extracted field, every AI verdict, every manager decision, every timestamp is persisted to Dataverse in a relational schema. The record supports audit review. If finance asks why a receipt was flagged, who overrode it, and when, the answer is a query away, not a forensic reconstruction.
Modular: any back-office system plugs in
Dataverse is the system of record in the demo. Your ERP, your AP system, QuickBooks, NetSuite, SAP: any of them next. Power Platform offers integration connectors, with custom contracts available where an integration needs one. Delivery effort depends on the target system and its controls. The approved expense posts to the system of record without a user ever logging into it.
Same photo, parsed. Vendor, date, category, subtotal, tax, total, and a full line-item breakdown: rendered as an Adaptive Card in Teams. Extraction is a lightweight GPT-4.1-mini call.Not "rejected": a plain-English explanation citing which line items violated which policy rule, by amount. The reasoning call uses a reasoning-class model because cross-rule logic matters here.A hotel folio with nights, rate, and room service extracted cleanly into the same schema. Payment card detected. Categorized as Lodging and Meals & Entertainment at the line-item level.Copilot Studio / Power Automate canvas: Build LineItems JSON → Build AdaptiveCard → Run a multistage approval → Condition routing. Low-code surface, enterprise-grade architecture.
INDEPENDENT PRODUCT / CONSULTING ACCELERATOR
Power Platform X-Ray
Make a consulting handoff repeatable.
Inventories, structural health checks, dependency diagrams, provider adapters, and export bundles turn architecture knowledge into reusable delivery material.
Uploaded solution files are treated as untrusted model input: their contents are fenced off as data the model must not follow, injection attempts hidden in uploaded files are tested against a live model, and a content security policy keeps the page from loading images from other sites or sending data anywhere except the AI provider and analytics.
Power Platform is one part of a broader toolkit spanning Azure, GCP, Databricks, OpenAI, Claude, and Gemini.
I built this when my wife was looking for remote work and a few friends were in the same spot. It screens job leads against what each person needs, so they only see the ones worth their time. Underneath are the problems I ask teams to solve: model resilience, visible economics, tenant boundaries and alerts that deserve attention.
What it costs, to six decimals
Per-agent spend, total tokens, and a thirty-day projection off current burn. Rates are configuration, not hardcoded constants. This is the panel that exposed the reasoning-token gap: the one that had my estimates running at 60% of the real bill.
THE DECISION BEHIND THE SYSTEM
A business signal is not a system failure
Operational reports classify business and system anomalies separately. A business fluctuation cannot become a critical system incident, and an AI narrative needs a corroborating critical system anomaly before escalating overall health. Regression tests cover that boundary.
Architecture, scope & additional evidenceExplore the technical decisions and product screenshotsShow detailsHide details
I designed and operate an independent career lead platform built around ingestion, active search, scoring, retrieval and resume tailoring. Its newer work focuses on keeping the system understandable under change: error-aware model fallback, per-call cost tracking, configurable routing and operational reporting. August 2026 improvements separate business fluctuations from system-critical failures, so a narrative model cannot turn a quiet traffic day into an invented infrastructure diagnosis.
How the system works
Gmail digests + live web search ingested
Per-agent model routing by task complexity
LLM scores each lead 0–100 against each person's needs
pgvector retrieval refines and enriches
Qualified leads trigger resume tailoring
Model usage metered, budget alerts checked
Architecture
Ingestion, analysis, active search and resume generation work alongside a retrieval service. A scheduled worker coordinates pipeline processing while a separate API serves the dashboard. Ingress pulls Gmail digests and live web search into a normalized lead store; the analyzer scores and enriches; a micro-score gate filters active-search results before expensive downstream work. Every model call crosses one instrumented boundary that resolves the model from task-level config, applies error-class-aware fallback across four tiers, retries transient failures with full-jitter backoff, meters prompt, output, and reasoning tokens against a versioned rate table, and writes per-call cost to the database. Self-healing model correction runs on a guarded background thread with idempotency, a write-storm cooldown, and an explicit test-environment bailout: a guard added after daemon threads outlived mock teardown and sent real alerts during a test run. Retrieval is pgvector similarity with adaptive pooling and an LLM refinement pass that fails open. Storage is Supabase Postgres with Row Level Security; the API and worker deploy as one Docker image across two services, with the frontend on Vercel.
Technology
Python
Gemini (multi-tier routing)
pgvector · 768-dim embeddings
Supabase Postgres + RLS
FastAPI
Docker · Railway
React + TypeScript
GitHub Actions
pytest (tiered markers)
Scope
Independent product I build and operate: backend agents, a React dashboard, tenant-aware storage, model-routing controls and operational reporting. Recent work adds durable abuse rate limits, fail-closed bot checks and email outcome reconciliation. Spend monitoring compares month-to-date usage with configured alert thresholds so I can act before cost becomes a surprise. The codebase carries about 3,000 automated tests.
Delivery evidence means what it says
Email records distinguish relay acceptance from confirmed delivery. Bounce reconciliation updates outcomes, while durable rate limits and fail-closed bot validation reduce abuse at the waitlist boundary.
Model resilience as an operating capability
Four-tier fallback: primary, class fallback, a hardcoded safe floor, then a rolling latest alias, which is only the last-resort tier. The routing is error-class aware, which is the part most retry logic gets wrong: a 429 or 503 is transient and retries in place with full-jitter backoff so a concurrent worker pool doesn't stampede an already-struggling endpoint, while model availability or permission failures take the fallback path instead of repeating a request that cannot succeed. A fallback chain with fewer than two distinct models is impossible by construction; if config drift collapses it, backstop models are injected. The operating history includes a model-family migration and fallback hardening after model availability failures.
I found a 40% hole in my own cost telemetry
Reasoning models emit internal thinking tokens that bill at the output rate but are not included in the standard output-token count. Before I caught that, my internal cost estimate was roughly 60% of the real cloud bill. Every projection I had was wrong by nearly half, and nothing was obviously broken. The meter now bills prompt, output, and thinking tokens against a versioned rate table, with month-to-date spend checked against a budget ceiling and alerts at a configurable threshold. Knowing what a system costs is a different discipline from making it work, and it's the one that gets a program cancelled.
Evals with a dollar figure attached: including the upgrades I turned down
Each agent task has a weighted scoring rubric with per-criterion minimum pass rates: schema validity and factual consistency have explicit acceptance floors, with reasoning quality and score correlation weighted beneath an overall threshold. Samples are drawn from real production tables, and every run writes outputs to disk for human adjudication. The committed results include failures. One candidate model scored 0.93 on weighted parity but missed its gate-alignment floor and would have raised monthly cost from $0.63 to $2.47. Rejected, with the receipt kept. I kept the existing model because the upgrade failed the required evaluation. The current evaluation harness adds rule-based labels and a two-judge model panel for five of the agent tasks, with hard gates such as no lost qualified leads before a model change can ship.
Spend and quota brakes that act on their own
Paid data sources have circuit breakers that step from warning to critical to a hard stop before a quota runs out, and one pipeline-wide pause switch stops all processing. Active search has an hourly spend and call-count brake that fails secure.
Right model for the right task, declared as configuration
Fifteen agent tasks map to model classes rather than model names, so cost and capability are tuned per task instead of per system. Unknown tasks default to the cheaper class to limit cost exposure. Resolution walks task-level config, then a system default, then the hardcoded floor, which means an operator can retune the economics of the whole pipeline without a deploy or a developer.
Chaos testing for the failure modes that actually happen
Twenty numbered fault-injection scenarios simulate the real ways LLM infrastructure fails: immediate cascade on a retired model, retry-then-succeed under rate limiting, retry-then-exhaust-then-cascade, permission failures, every tier failing at once, a missing API key. These are the conditions that take a pipeline down at 3am, and they run as tests rather than as incidents.
Retrieval that degrades honestly
pgvector similarity search with adaptive pool sizing. Longer queries widen the candidate pool before an LLM refinement pass. When the refiner returns empty, it fails open to the raw matches instead of returning nothing, because a degraded answer beats a blank screen. Index health is monitored for unindexed rows and malformed embeddings, so silent retrieval decay surfaces before users feel it.
Multi-tenant isolation enforced at the database, not the application
Row Level Security on Supabase with isolation tests across the tenant boundary, redaction utilities for sensitive fields and operational traces, secret redaction inside tracebacks, and self-repair for malformed model JSON. A pre-push hook blocks on failing unit tests locally, and CI gates integration tests behind unit tests passing so a broken build fails fast and cheap.
Where the domain and my background meet
Underneath the automation this is candidate-to-role matching: scoring against a profile, threshold gates, and a qualification decision. That is the same judgment I spent years exercising manually on a consulting bench: who fits this requirement, at what confidence, and is it worth putting them forward. Building the automated version taught me exactly which parts of that judgment survive automation and which parts still need a person.
Each agent's model and persona are configuration an operator can retune without a deploy. Cheaper models handle extraction; reasoning-class models handle judgment. Choosing the frontier model for every step is how AI budgets detonate.Every cycle accounted for: processed, created, deduplicated, loop guards fired, errors. Per-user breakdown with durations and a filterable audit trail. When something goes wrong at 3am, the question is which stage and which record, and the answer is a query rather than a forensic reconstruction.
Independent product · Controlled rollout · 2026
The Wrap Sheet: Creative AI, Engineered for Accountability
A league-specific beat writer with recurring characters, persistent storylines and illustrated recaps. The product pairs creative generation with structured factual checks, bounded model spending and commissioner editorial control.
One story. A distinctive visual identity.
A clay-style interpretation of a league recap. Recurring characters, sourced events, and an editorial review step connect the creative output to the product.
THE DECISION BEHIND THE SYSTEM
Deterministic checks around creative generation
Typed claim markers bind generated numeric assertions to entities, relations and source facts. The claims gate resolves those markers in code and rejects detected mismatches. This validates supported structured claims; it does not replace editorial review or certify every word and image.
Architecture, scope & additional evidenceExplore the technical decisions and product screenshotsShow detailsHide details
This began with the work of writing a weekly league recap. Turning it into a product meant solving more than prose generation: reliable facts, continuity, tone, image generation, cost, review and delivery. The engine computes facts from league data, drafts against a versioned persona and checks structured numeric claims with deterministic code. A commissioner reviews and can edit the result before separate approval and sending. These controls make generated content inspectable; they are not a guarantee that every sentence or rendered image is error-free.
How the system works
League API data normalized
Facts derived and cross-checked
Persona + storyline context assembled
Writer and illustrated output generated
Structured claims checked; bounded repairs
Commissioner reviews → approves → sends
Architecture
Platform data → normalized typed records → derived facts and consistency checks → persona, lore and storyline context → generation through a metered model port → deterministic claim gates and bounded repairs → illustrated recap packet → commissioner review, separate approval and send. Delivery handling records outcomes and preserves recipient-level bookkeeping when a transport result is ambiguous.
Technology
Python + Pydantic
Claude text generation
Gemini image generation
FastAPI
Supabase + RLS
MyFantasyLeague API
Vercel + Railway
Offline replay + mutation tests
Scope
Independent product in controlled rollout: a fact-processing engine, generated text and illustrations, commissioner editorial controls, operating dashboards and audited delivery. I designed the architecture and build the product end to end.
Commissioner authority remains explicit
Review, edit, regenerate, approve and send are deliberate product controls. Approval and delivery are separate actions. Edits made after generation still need human review, and preview reminders must not be confused with an unattended delivery promise.
Cost limits before another attempt
Model calls pass through a metered port and an append-only cost ledger. The repair chain checks estimated cost before calling again, limits attempts and records actual spend. Recorded calls can be replayed without a fresh model charge.
Storylines that carry forward
League lore and carry files bring preceding storylines into subsequent generated weeks. Versioned persona packs control voice and tone, while recurring visual characters give the illustrated output a recognizable identity.
Quality gates that can actually fail
Deterministic fact checks, mutation tests, offline replay and bounded repair paths make failures visible. Local adversarial review is the required review path; the cloud review bot is advisory. A missing advisory response is not represented as a completed review.
Image generation that survives a provider limit
If Google AI Studio hits a quota limit or keeps returning server errors while drawing images, the app can retry the same Gemini model on Google Vertex AI, so one provider's limit does not stop a run. Text generation has no second provider.
A product, including its operating surface
The implementation includes commissioner and admin interfaces, generation controls, delivery auditing, a read-only partner API and illustrated draft capabilities. Release gates keep new capabilities separate from the version available to commissioners.
A newspaper-style treatment of the same recap demonstrates configurable visual direction. The underlying facts and review boundaries remain separate from the rendering style.
Earlier delivery & reusable building blocksSmaller and earlier work, summarizedShow detailsHide details
Scope and dates vary; none of these is presented as an enterprise deployment claim.
Copilot Studio
Multi-Agent Helpdesk Orchestration
Master Copilot routes to mission-specific sub-agents for intake, autonomous ticket creation via adaptive cards, real-time status retrieval.
Power Platform
Talk to Your Data
Hybrid search using Power App and Azure AI Search for precision retrieval across thousands of unstructured documents with direct PDF page linking.
Federal
RFP/RFI Analysis Engine
Custom Copilot for federal opportunity assessment.
Federal
Resume Analysis for Proposal Staffing
Automated candidate classification and scoring against federal contract requirements.
Enterprise OpenAI and Gemini connectors bring provider access into the Microsoft ecosystem with shared authentication, throttling, and auditability patterns.
THE NEXT CONVERSATION
Let’s talk about the practice you want to build.
Building an AI practice takes client trust, capable people, and realistic commitments. That is the work I want to lead.
