From 10 Hours of Hand-Built Analysis to Minutes of Grounded Insight

A performance-marketing agency running 50-60 enterprise clients spent roughly 10-12 hours building each weekly paid-search report by hand. The data pull was the easy part; what consumed the week was judgment. RapidCanvasre-engineered the workflow around a single architectural principle, and the agency's own analysts now run it themselves.
‍

Challenges Faced

10-12 hours per weekly report, and half of it was judgment

About two of those hours were mechanical (data pull and formatting). The rest was analytical judgment no dashboard could replace: roughly 3 hours of year-over-year context and attribution, 3 hours of brand and non-brand narrative with geo drill-down, and 2 hours on the executive summary and reallocation recommendation. Across 50-60 clients on a weekly cadence, report assembly alone consumed close to two full-time roles' worth of effort.

The judgment layer had hard requirements

• Year-over-year context
• Volume-weighted attribution
• Channel by geography cross-cuts
• A concrete budget reallocation

Every obvious solution missed the same gap

The agency had tried three approaches before RapidCanvas, each hitting the same ceiling. Business-intelligence (BI) dashboards made the key metrics visible but couldn't say “this is good because last year it was worse” or recommend where to move budget. Scheduled database queries and alerts could flag threshold breaches but couldn't tell whether a breach mattered, attribute a cause, or synthesize a recommendation. Ad-hoc AI chatbots were fast to try but impossible to trust: not tied to the real data, they made up numbers, rounded too aggressively, and returned generic advice that could never be shared with a client.

A slow, brittle data path

The dashboard read directly from a 1-2M-row raw daily table and aggregated on the fly, which pushed queries to several seconds and made deep multi-dimensional slices impractical at report time.
‍

Solution Implemented

RapidCanvas built the system around one strict separation: deterministic code computes every number first, and the language model only narrates the locked results.

The core principle

The code does all the math; the AI only writes the words. Every total, comparison (week-over-week, year-over-year and last-4-weeks) and percentage is calculated in advance and locked into a Verified Facts list. The AI is given only those locked numbers and is forbidden from inventing any figure that isn't on the list. It can explain, compare and recommend, but never calculate.

How the system is built

Behind the scenes, a daily process pulls the agency's ad data, replaces the previous day's records, and pre-calculates every number into fast summary tables, so the app loads any view in under a second. The analyst-facing app layers the AI on top, with a built-in prompt editor and per-bullet feedback. (Under the hood: an Azure SQL data source, a daily Python pipeline built with FastAPI, pandas and SQLAlchemy that produces weekly, monthly and quarterly summary tables, and a React + Vite + TypeScript + shadcn/ui app with PostHog analytics backed by a small MySQL store.)

Step 1: What Changed (calculated instantly, no AI involved)

The analyst selects a week. The backend reads the pre-aggregated weekly rollup (~30K rows) and computes comparison tables across all slices (WoW, L4W and YoY across channel, geography and product) in tens of seconds. Alongside the display tables it extracts the locked Verified Facts block, the numerical contract the entire AI layer is built on.

Step 2: Why It Changed (several AI models cross-check each other)

The Verified Facts block is injected into a system prompt that encodes the agency's methodology as hard rules, and the same prompt runs in parallel across three frontier models. The grounding rule is absolute: cite the Verified Facts verbatim and use no other numbers. Runs are reproducible (temperature 0, fixed seed, so the same week yields the same output), and a context cap keeps the prompt inside the model window. The output is exactly ten bullets in a drill-down hierarchy: topline, then channel, then geography, then theme, honoring YoY context, volume-weighting, the brand/non-brand split, channel-by-geo cross-cuts and contribution percentages whenever a move exceeds 10%.

Step 2.5: Curation

Each of the ten bullets gets a thumbs-up or thumbs-down, and a thumbs-down opens a free-text “what went wrong?” field. Approved bullets are injected into the executive-summary prompt as positive steering; rejected bullets, with their reasons, become explicit do-not-repeat signals. The feedback also accumulates as a long-term prompt-tuning dataset.

Step 3: Executive Summary

A three-bullet, slide-ready brief that transfers straight into the client's weekly deck: brand and non-brand in separate bullets, closing with a specific budget reallocation, written in the agency's own voice: active tense, every claim adjacent to a number, no hedging.

Parallel models, one synthesized answer

Every model receives identical input (the Verified Facts block, the system prompt and a set of golden examples). GPT-5.2 is the primary model and handles single-model runs; Claude Sonnet 4.5 provides an independent parallel read; Gemini 2.5 is a third read to reduce shared blind spots. Claude Opus 4.6 is the hardcoded synthesizer on every multi-model run: it detects disagreements across the parallel outputs and surfaces them explicitly rather than averaging them away.

The Verified Facts contract

Pre-computed numbers are formatted as a locked reference block placed before anything else the model sees, for example: overall spend, week over week, $219,800 (up 24.1%). The instruction to the model is blunt: “Use these exact numbers. Do not calculate or estimate any other numbers. If a number is not in this block, output N/A.”

A self-improving system

Per-bullet curation doubles as a steering instruction and shapes the executive summary immediately, in the same session. Each analyst owns named prompt versions saved to their own account: open the editor, change the prompt, name it, save, set it active, with no code and no engineering cycle, and multiple versions coexist for side-by-side comparison. A set of analyst-approved question-answer pairs is pinned into every prompt as approved example answers and used as a benchmark: new versions are tested against it before they are promoted.

Data architecture for sub-second reads

Every view reads from pre-built summary tables rather than the raw data, so any week, region or breakdown loads in under a second.
‍

Results and Benefits

Targeting 75-85% less time per weekly report

Weekly report time drops from roughly 10-12 hours toward under an hour. Live on the flagship account, with the first analyst already running it themselves.

About two full-time roles' worth of capacity freed

Portfolio-wide, the capacity once consumed by report assembly is redirected to client strategy, and the architecture makes each additional client incremental rather than a rebuild.

Under two weeks from kickoff to working demo

Productionized in weeks once the process was made rigorous: the decisive move was the architecture, not a model choice.

Sub-second comparison tables

Under a second for any week, any slice, any granularity. The tooling is never the bottleneck.

Three independent model perspectives per run

Disagreements surface explicitly rather than being averaged out, with Claude Opus 4.6 reconciling them into a single narrative.

A system that improves with every run

Analyst curation, captured per bullet with reasons, compounds into a long-term prompt-tuning asset and shapes outputs immediately in-session.

Numbers that reconcile by design

Because the model is architecturally blocked from producing unverified figures (it must cite the Verified Facts block verbatim and output N/A for anything not pre-computed), no hallucinated statistic reaches a client deliverable.

The agency already had the data, the expertise and AI in use. What it lacked was a reliable, repeatable way to turn numbers into judgment at scale. The decision that changed everything wasn't which model to use; it was the strict separation between what code computes and what the model is allowed to say.