RM
← Case Studies

Data product / Raw-data benchmark intelligence engine

Benchmark Intelligence Engine

A raw-data benchmark dashboard for share, rank, monetization, aggregation, and local scenario forecasts.

A public-safe benchmark intelligence dashboard that turns five years of synthetic monthly revenue and traffic observations into tracked market-share analysis, rankings, monetization diagnostics, period aggregation, and local scenario forecasts. The system starts from 480 raw monthly rows, then generates the intelligence layer in code: benchmark rows, shares, ranks, efficiency metrics, growth metrics, and forecast scenarios.

Demo mode only: synthetic companies, synthetic values, public-safe labels, and no real company, client, logo, or private source data.

React/Vitesource_monthly480 raw rowsLocal forecast enginePublic-safe synthetic data
Executive benchmark dashboard generated from five years of raw synthetic monthly data
Executive summary generated from five years of raw synthetic monthly data. Synthetic demo data only.

Case Snapshot

The strategic brief

The problem, the system response, the available proof, the strategic value, and the intentional boundary.

01Problem
Benchmark analysis is hard to repeat when raw observations, metric definitions, validation, scenario work, and executive questions are disconnected.
02System
A raw-data benchmark intelligence engine with a source_monthly contract, canonical metrics pipeline, generated benchmark rows, executive views, and local scenario forecasts.
03Proof
Public-safe repo, 480 synthetic monthly rows, generated market_total and market_average rows, working Players/Battle Arena views, validation logic, and forecast labeling.
04Value
Helps answer who is gaining tracked benchmark-set share, who is more efficient, which players are improving, and what scenario should be reviewed next.
05Limitation
The public case uses synthetic companies and values; forecasts are scenario projections, not real market prediction.

Business Context

The workflow problem behind the project

Competitive analysis often lives in disconnected spreadsheets, screenshots, and one-off decks. The same questions repeat: who is gaining share, who is more efficient, which players are improving, and what may happen next.

System / Solution

How the workflow is bounded

A clean source_monthly contract feeds a canonical pipeline that validates raw observations, generates benchmark rows, calculates shares/ranks/efficiency metrics, creates local scenario forecasts, and renders the result as a React/Vite executive dashboard.

Inputs

480 raw monthly observations: 8 synthetic companies across 60 months, plus 12 synthetic public-safe events.

Workflow

Validation, canonical benchmark pipeline, generated market_total and market_average rows, forecast generation, view-model generation, and release checks.

Processing logic

Tracked benchmark-set share, ranks, growth, indexed metrics, revenue per visit, monetization gap, period aggregation, and forecast-derived metrics are calculated in code.

Output

Executive dashboard, Players/company profiles, Battle Arena, forecast view, ranking tables, and public-safe data health context.

Guardrails

Synthetic-data discipline, no real client or competitor data, and public-readiness validation before publishing.

What changed

From prepared dashboard JSON to generated benchmark intelligence

I rebuilt the project across several sprints: from prepared dashboard JSON to raw source_monthly observations, from static benchmark rows to generated market_total and market_average rows, from precomputed metrics to runtime calculations, and from fragile profile/battle routes to working Battle Arena and Players/company profile views.

480raw monthly rows
8 × 60synthetic companies × months
12synthetic events

Raw data contract

The public JSON stores raw monthly observations only. Legacy data.interface payloads remain supported as backwards compatibility, but they are not the preferred source of truth.

Generated benchmark rows

market_total and market_average rows are generated at runtime from observed company rows, then excluded from share denominators and ranks where appropriate.

Generated metrics

Market share, ranks, growth, indexed metrics, revenue per visit, monetization gap, annual aggregation, and range aggregation are calculated in code.

Working product views

Executive dashboard, Players/company profiles, #/company/:id routes, legacy #/empresa/:id routes, Battle Arena, and Forecast view all work from generated canonical rows.

Architecture

The repeatable intelligence pipeline behind the chart layer

The final architecture separates source data from benchmark intelligence. Raw monthly revenue and visits enter through data.source_monthly; the canonical pipeline validates the rows, normalizes entities, calculates benchmark metrics, generates synthetic benchmark rows, creates forecast rows, recalculates forecast-derived metrics, and returns dashboard-ready interface rows.

Raw source_monthly dataValidationCanonical benchmark pipelineDerived metricsSynthetic benchmark rowsLocal forecast engineReact/Vite dashboard
01

Raw observations

Five years of synthetic monthly revenue and visits: 2021-01-01 through 2025-12-01.

02

Validation

Accepts source_monthly rows and rejects derived benchmark fields from the raw source layer.

03

Canonical pipeline

Builds dashboard-ready rows from raw observations while keeping the public JSON small, readable, and safe.

04

Derived intelligence

Calculates tracked benchmark-set share, ranks, indexed values, growth metrics, revenue per visit, and monetization gap.

05

Scenario forecasts

The local_engine default projects revenue and visits, then sends forecast rows back through the benchmark pipeline.

06

Dashboard UI

Renders market overview, Players, Battle Arena, company profiles, forecast scenarios, and data health context.

Visual proof

Core product views from generated benchmark metrics

The shipped interface exposes the product surface around the pipeline: executive overview, rankings, market-share movement, Players/company profiles, Battle Arena comparisons, and forecast scenarios generated from the five-year history.

Data contract

source_monthly is the source contract

The JSON stores raw monthly observations only. The app generates interface rows internally: forecast rows, market_total and market_average rows, market share, ranks, indexed metrics, growth metrics, revenue per visit, and monetization gap are all generated in code.

data-contract.json
{
  "ok": true,
  "meta": {
    "dataset_name": "Demo Benchmark Dataset",
    "currency": "EUR",
    "source_type": "raw_monthly_observations",
    "data_policy": "Synthetic demo data only. No real company or client data is included."
  },
  "data": {
    "source_monthly": [
      {
        "date": "2025-01-01",
        "company_id": "focus",
        "display_name": "Focus Brand",
        "market": "Demo Market",
        "type": "own",
        "revenue": 125000,
        "visits": 82000,
        "active": true
      }
    ]
  }
}
source_monthly
Raw monthly observations for date, company_id, display_name, market, type, revenue, visits, and active state.
generated rows
market_total, market_average, and forecast rows are generated at runtime, not stored as source records.
generated metrics
Tracked share, ranks, indexed metrics, growth, revenue per visit, and monetization gap are recalculated by the canonical pipeline.

Public-safe build discipline

Synthetic data is part of the product design

The repo is designed to be inspected publicly. It uses synthetic company names, synthetic values, no private client data, no credentials, no required backend, no paid API dependency, validation scripts, public audit checks, security notes, deployment documentation, and a deterministic demo-data generator.

pnpm generate:datapnpm testpnpm buildpnpm validate:datapnpm audit:publicpnpm typecheckpnpm lint
  • No actual company performance data, competitor datasets, private client records, credentials, or private API URLs.
  • The public demo uses the local statistical engine by default; no Python service, model weights, backend, or paid API are required.
  • TimesFM remains optional infrastructure only and is not how the public demo is positioned.

Result

A public-safe benchmark engine

The outcome is a repeatable benchmark intelligence engine that starts with raw synthetic observations and produces the analytical layer needed for executive market-share, ranking, monetization, aggregation, and scenario-planning views.

Build

  • Clean source_monthly contract with 5 years of synthetic monthly data: 8 companies × 60 months = 480 rows.
  • Canonical benchmark pipeline generates market_total, market_average, tracked benchmark-set share, ranks, growth, indexed metrics, revenue per visit, and monetization gap.
  • Local scenario forecast engine projects revenue and visits, then recalculates shares, ranks, efficiency metrics, and benchmark rows for each scenario.

Outcome

  • Executive dashboard, Players/company profiles, Battle Arena, Forecast view, #/company/:id routes, and legacy #/empresa/:id route support are working.
  • Public-ready repo with generate:data, validation, public audit, deployment documentation, security notes, and release checklist discipline.
  • Portfolio-safe demo that shows the product without exposing actual companies, private client records, or private infrastructure.

Why It Matters

Reliability beats novelty

Competitive intelligence becomes more valuable when the analysis logic is repeatable. This project turns raw monthly observations into an inspectable benchmark pipeline instead of treating the dashboard as the product.

Client Relevance

Where this becomes useful

A client-facing version could help brand, ecommerce, marketing, or strategy teams compare markets, monitor positioning signals, diagnose monetization gaps, and produce clearer executive readouts without rebuilding the analysis from scratch.

Discuss a Similar AI System

Have a creative system worth extending?

If your team has a creative process, internal tool, campaign workflow, or brand system worth extending with AI, send a short brief and I'll help define the clearest system logic.