Platform · Performance

Measured, not promised

Every performance claim on this site is an assertion inside our own test suite, with a millisecond ceiling that fails the build when it is crossed. Here is each number, what it measures, where it was measured, and the caveat that travels with it.

The methodology

Budgets, not adjectives

Three rules make a number quotable here. Every row in the tables below obeys all three.

  1. Gates in every build

    A performance claim is a test with a ceiling. 54 of 439 backend test files assert a timing bound; a crossed ceiling fails the build. The gates run on one dedicated machine so timings are consistent, and a budget is never moved to accommodate a slow machine.

  2. One machine, two setups

    Every number was measured on one machine in our lab, in one of two setups. The single-node setup runs the embedded columnar fact store in-process. The scale-out setup runs the scale-out column store with distributed job runners, the cache and a control database with split roles. Neither is a cloud region or a cluster.

  3. Our own test data

    Synthetic worlds and demo tenants with fictional brands, never a customer workload, because there is none to quote. Nothing on this page is a forecast-accuracy claim; the accuracy machinery is a capability we surface, not a result we have delivered.

The numbers

Every number we quote, and what it actually measures

Read the caveat column as carefully as the first. A number without its framing is a number we would not put on this page.

Interactive reads: from a million rows to a billion
NumberWhat it measuresWhere it was measuredCaveat
33 / 34msa grid pivot page (p50 / p95) over a one-million-row world, brand × store, mixed SUM and AVG, a 100-week window, served through the real HTTP grid door; a 100-row result pagesingle-node setup · an automated build gatewarm (3 warm-ups, 15 samples); in-process test client, no network hop; a synthetic test dataset. The tight budget was ≤ 100 ms. This sits 3× inside it.
12.5msrolling one million fact rows up to one thousand groupssingle-node setup · an automated build gatethe test asserts under 1 s: 12.5 ms is the recorded value, not the assertion; single user, no concurrency. The scale-out setup later measured 18.5 ms.
1.02sone million rows written in bulk through the full storage-contract pathsingle-node setup · an automated build gatethe same synthetic test dataset.
1,003,750,000rowsa retail day-level fact table on the scale-out adapter: 2,500 items × 2,500 stores × 730 days, 22 % listed-pair sparsity, 438.6 MiB on diskscale-out setup · our own benchmarkour own test data; not a production workload.
2.39Mrows/swrite throughput at billion-row scale, through the storage contractscale-out setup · the same benchmarkthe same benchmark, the same caveat.
127.8msa workbench-shaped pivot page, department × region, a one-month window, over the billion-row tablescale-out setup · the same benchmarkcold; 13.8× faster than the path it replaced. It missed our own 100 ms tight target by 28 %, and we recorded that.
65.6msa 500-store × month drill on the billion-row tablescale-out setup · the same benchmarkinside the tight budget.
124.8msan interactive pivot read immediately after a fresh 100,000-row write at billion-row scalescale-out setup · the same benchmarkthe churn case; the earlier ~6 s churn tail is gone.
An edit, and what follows it
NumberWhat it measuresWhere it was measuredCaveat
70msa single cell edit reaching its downstream measures: edit → buffer → flush → event bus → dependency graph → recompute, the full stack (re-measured at 74 ms)single-node setup · an automated build gateone edit, one tenant; the gate asserts under 500 ms. Not a concurrency number, and not the same thing as the live rule cascade in the next row.
~505msa live rule cascade, steady: the full downstream rule chain firing after an edit on a live demo tenant (from 2.3 s; the era began at 24.1 s)a live demo tenanta different measurement from the 70 ms gate: a whole rule chain, not one edit’s propagation. We name which is which and never blend them.
2,875,321 → 6rowsone cell edit’s downstream cascade, before and after bounding: the rows it re-evaluated, and the time it took: 24.1 s → ~2.2 sa live demo tenantthe ~2 s remainder is a named open seam, not a finished number.
< 500msthe platform’s edit-visibility budget: an edit visible to its editora budget every gate holdsa budget we hold, not an average we report. What was proven under load is the next row.
10 / 193 to 212mseditor latency (p50 / p95) under sustained load on the scale-out setup: 25 edits/s + 10 reads/s for 60 s, run twice, zero failuresscale-out setup · an automated build runinside our 500 ms limit. This is not “50 concurrent editors”. That target has not been run. The single-node setup under the same load recorded p95 526 ms, above our own limit; we record it as a miss, not a pass.
Rollups, storage engines and scenarios
NumberWhat it measuresWhere it was measuredCaveat
48,034 → 105msan all-history 24-month rollup over the full billion rows: before and after a declared rollup layer; 456× faster served, identical totalsscale-out setup · the same benchmarkquoted only as the pair: that shape needs a declared rollup layer, built once asynchronously in 48.7 s. On its own the 48 s is the shape that did not fit the interactive path, and we say so.
identicaltotalsthe storage swap-proof: both storage engines return the same totals at both scales; one configuration value is the whole switch, zero caller changesboth setups · a permanent automated build gatenot “engine A is faster than engine B”: the embedded engine wins small aggregates and the scale-out engine’s curve is flatter. The claim is the right engine per tier, the same answers.
208.5Mcellstwo live tenants re-materialised from one storage engine to the other, at about 2M cells per second, parity exactdemo tenantsdemo tenants, our own data.
74msthe scenario engine’s gate: the branch chain, the root rule, the cascade and the save walls, togethersingle-node setup · an automated build gatesingle-node setup.
The access envelope and tenant isolation
NumberWhat it measuresWhere it was measuredCaveat
143 / 167 / 170msresolving and compiling one principal’s effective access (p50 / p95 / max, cold) across 1,000 users · 1,000 roles · 10,000 grants; p95 0.02 ms warman automated build gatea bulk-provisioned test dataset with a real hierarchy closure. “Flat, no cliff” is the claim.
482msprovisioning a schema-isolated tenant over HTTP: 94 tables at the same migration head, 89 policies in its own schemasingle-node setupsingle-node setup.
The science, measured
NumberWhat it measuresWhere it was measuredCaveat
36,220 · 31,151seriesa full-portfolio model contest as a governed job: series classified · series judged; 1.16M verdict cells and 800k published forecast cells in 108.9 minutes; 1,090 series skipped honestly, 0 refuseda demo tenantwe quote the throughput only, never that run’s accuracy figure.
14 vs 169msthe same lifecycle run with a policy setting off, then on: the “off provably skips” proof; the footprint ladder that reports what a change reaches, 32 mssingle-node setup · an automated build gatepost-fix figures, after the adversarial review pass.
9.2 % → 3.7 %the median gap between the explainer model and the winning model’s forecast: how faithfully the explanation reproduces the number it explains; the worst-5 % tail 26 % → 17 %a demo tenantuse as “the explanation got twice as faithful”, a fidelity figure, never an accuracy claim.
0 of 2,310seriesthe measured verdict that a weather driver did not earn its seat: paired champion score 0.5093 → 0.5104 with weather in the rooma demo tenanta demo world whose demand was generated without weather. This is the refusal story: a platform handed real weather that measured it and said no, not a finding about weather.
26msa 10,000-edge bill of material exploding: multi-level, where-used, with quantity-per, scrap, effectivity, diamonds, cycle-safesingle-node setup · an automated build gatethe engine carries the bill of material by design; the manufacturing module is built with our first manufacturing customer.
21Mcellsa demo tenant’s history landed through the governed connector pipeline, 0 rejectsa demo tenantdemo tenant.
The structure of the product, counted
NumberWhat it measuresWhere it was measuredCaveat
41 · 20 · 1widget types · studio surfaces · the one route the whole planner application renders from: every screen is metadatathe source treecounts as of September 2026.
8contractsthe platform’s swappable interfaces: control store, fact store, compute plug-in, connector, event bus, cache, job runner, feature storethe source treenone
59packagesthe demand module, shipped as metadata packages rather than engine codethe source treecount as of September 2026.
54 of 439test filesbackend test files that assert a timing bound: the performance budgets enforced in every buildthe source treecount as of September 2026; “budgets are tests”, not a coverage claim.
0linesof module code to build a whole application from an empty install, through the product’s own doors: the platform core’s final acceptance gatethe acceptance recordone application, walked end to end; the platform core passed every one of its acceptance gates before the first module was built.

This page’s own vitals

What this page scored, dated

A performance page should be measured too. These are this page’s own lab results from the same gate every page of this site passes before it ships.

Lighthouse · mobile
100 · 100 · 100 · 100 performance · accessibility · best practices · SEO
Lighthouse · desktop
100 · 100 · 100 · 100 performance · accessibility · best practices · SEO
Largest contentful paint · lab, mobile
1.7 s
Cumulative layout shift · lab, mobile
0.00
Total blocking time · lab, mobile
0 ms
Measured on
2026-09-15 simulated mobile and desktop, the site’s own release gate

Third-party scripts on this page: none. Fonts: self-hosted. Stylesheet: inlined.

Measure it on your own data

Bring a slice of your history and your hierarchies. We show the engine working on them: the same budgets, your numbers.

Request a demo

a working demo on your data · no commitment