Meridian: a risk portal that survives its engine changing shape
A concept build for a members-facing portfolio risk platform — firm overview, per-book risk, an interactive scenario builder, attribution and an append-only audit trail — designed so that the engine behind it can change its output format without a single dashboard being touched.
About this page. Meridian is a Cogwheel concept build, not a client engagement. Nobody commissioned it, and there is no fund or risk desk behind it. Every firm, book, client and figure on its screens is generated, and the product labels itself a demonstration platform throughout. What is real is the architecture and the engineering, which is what this page is about.
The brief
A business with its own analytics engine has a recurring problem that is not an analytics problem. The engine works. Getting its output in front of the people who need to act on it is the part that keeps breaking, and it breaks hardest when the engine changes.
Meridian is built around a single answer to that. The engine emits a versioned payload. An adapter validates it and maps it into one internal model. Every dashboard reads that model and nothing else. When the engine's schema moves, the adapter absorbs it and the front end does not move at all — which is a claim you can test on the live demo in one click.
Walk through it
Nine screens, captured from the running deployment: the landing page in two of its three themes, the architecture and contract sections that carry the argument, the portal itself, the scenario builder, and the sandbox where you can put your own payload through the adapter.
Landing, storm theme
One of three art directions, drawn on a canvas rather than shipped as an image: cloud banks drift inward, lightning strikes inside them, and a sunbreak opens in the middle with the product sitting in the clear. The composition is literal — turbulence at the edges of the frame, a clear view in the centre, which is the sentence the headline makes. It re-themes from CSS custom properties and renders a single composed still under reduced motion.
How it is built
A platform whose most deliberate feature is the seam between it and the engine it presents.
The engine stays the source of truth
The risk engine computes; the platform presents. A versioned adapter validates whatever the engine emits and maps it into one internal model, and every dashboard reads only that model. Nothing downstream learns the engine’s shape, so nothing downstream breaks when it moves.
A new engine is a file, not a change to the app
Each contract is a mapping declared as data — internal field to source path, with named transforms where units differ. Adding an engine adds a mapping file. The alternative, a branch inside the one function every dashboard depends on, makes the decoupling claim true in argument and false in the repository.
Point your own engine at it
The sandbox takes a pasted JSON snapshot through the real adapter and reports every field that resolved and every one that did not, naming the source path each was expected at. A payload that half-fits is reported rather than stored: every dashboard reads the whole model, so a partial snapshot would render as an error rather than as a smaller view.
Figures that cannot contradict each other
Live panels re-read on a timer, and each renormalises its parts back to their original total on every tick. Exposure always sums to the firm aggregate, the liquidity ladder always sums to 100%, and derived figures are computed from the same array the rows read — so no tick can put two numbers on screen that disagree.
What this build argues
That the boundary between an engine and the thing presenting it is the part worth designing, and that a demo should let you test the claim rather than take it on trust.
The problem it is built around
A risk engine already computes the numbers. They arrive as a nightly file, get pasted into a deck, and by the time the committee meets nobody can say which figures moved or why. Meridian is the layer that turns that output into something a risk committee can read, without rebuilding any of the analytics.
Why the contract toggle is the whole demo
The top bar switches the engine contract between v1.0 and v2.0. That re-ingests a genuinely different payload — renamed collections, nested posture, a rescaled score, every exposure field renamed — and the dashboards do not move. A gate asserts the two contracts normalise to byte-identical snapshots apart from the version string, so the claim is checked rather than asserted.
Showing the mechanism instead of describing it
The landing page argues by demonstration. The hero is the product in real markup rather than a screenshot. The architecture band puts engine, adapter and platform side by side with the actual payload travelling between them. The contract section flips the payload shape next to an internal model that stays still. Nothing on the page is a stock illustration of a concept the page is also explaining.
Three art directions from one token set
Light, dark, and a storm theme whose hero is drawn on a canvas: cloud banks drifting inward, lightning inside them, and a sunbreak opening where the dashboard sits. Canvas rather than video because a still cannot strike, and because the scene has to re-theme and reposition around a dashboard whose width changes with the viewport. Reduced motion gets one composed still and no animation loop at all.
Built with
The seam is the product
Most platform work of this kind couples the front end to whatever the data source emits, and the coupling is invisible until the source changes. Here the adapter is the whole design: one mapping file per engine contract, a stable internal model behind it, and a gate asserting that two differently shaped payloads land on byte-identical output. It costs a layer of indirection and buys the ability to say yes when a client tells you their schema is about to change.
Have an engine that needs a front door?
If something in your business already computes the numbers and the problem is getting them in front of people, this is the shape of the answer. The first conversation is free and it is mostly us looking at your output.