Accuracy without compromise

First in a series on how Edgelab actually works. No black boxes — we walk you through the machinery, in plain language, one piece at a time, so you finish each article knowing something concrete about the engine behind our risk numbers.

Measuring risk properly is hard and it's worth being honest about why.

Markets are enormous. A single wealth portfolio can hold thousands of instruments — shares, bonds, funds, private investments, structured products — and many of them don't move in a straight line. Their value bends and twists and the relationships between them shift exactly when it matters most, in a crisis. The outcomes that actually hurt are the rare, extreme ones, and those are the hardest to see coming. Capturing all of that faithfully takes an enormous amount of computation — far more than working out a simple average return.

Faced with that, most models cut corners. They simplify the world to keep the computation manageable: smooth off the awkward instruments, assume relationships hold steady, treat the strange products as though they behaved like ordinary ones. It's the practical choice and it's almost universal.

The trouble is what gets simplified away. A simpler model doesn't describe the market — it describes a tidier market that doesn't exist, one where the sharp, dangerous corners have been quietly sanded off. And those corners are usually the whole reason you were measuring risk in the first place.

We made the opposite choice and we made it at the start.

The founding choice: absorb the complexity

We began with structured products — among the most complex instruments in finance to value. They're built from many moving parts, they don't respond to the market in a straight line, and small assumptions about their behaviour produce wildly different answers.

The best method to assess their risk was already known — it was just complex and notoriously difficult to implement, so most of the industry reached for an approximation instead. We made the hard one work.

The principle that came out of it still governs everything we build: when something is complex, we absorb the complexity ourselves and hand you the best answer we can produce. Much of the engineering behind Edgelab is just the discipline of refusing the convenient shortcut.

How is a risk produced

Most of the heavy work happens overnight, so the answer is already waiting when you need it. After the market closes, Edgelab re-prices every instrument for every scenario it covers from the ground up — around 1.5 billion repricings, finished in under six hours, before sunrise. Ask a question the next morning and the answer comes back in about half a second, because the hard part is already done.

That overnight run isn't one big calculation. It's a chain of steps, each depending on the one before:

1. Gather the data. Pull in fresh prices and market information for everything we cover.
2. Calibrate the models. For example, before anything can be valued, you need the going rate to borrow money over different horizons — a week, a year, ten years. Mapped out, those rates are the curves, and they sit beneath the price of almost everything else.
3. Build the scenarios. A risk number isn't an instrument's value today — it's how that value holds up across a whole range of possible market conditions. That range is generated here: the set of market moves every instrument will then be re-priced against.
4. Price every instrument. Each one is valued using the data and the models built in the steps before.
5. Check the whole run. The full batch is validated before any of it is released.

Because each step rests on the one before it, the order isn't optional. And if a single step fails, the whole run stops — nothing downstream gets built on a broken input. "A chain is only as strong as its weakest link" is usually a figure of speech. Here it's how we've wired the system.

How we check the work

Accuracy is not created once — it has to be protected continuously.

There are four disciplines behind that work.

• We match the pricing formula to the instrument. We don't value everything with one general method. A plain bond is priced by adding up what it will pay over time, discounted because money in the future is worth less than money today; a multi-underlying structured product needs an entirely different and far heavier calculation. Plenty of systems stretch a single formula across everything because one formula is easier to maintain. We keep a pricing function fit to each kind of instrument, from vanilla bonds through to the most complex structured products, and we keep testing and improving them. More work for us; accurate analytics instead of rough estimates for you.
• We backtest our risk model. A risk forecast is a promise about the future, and we treat a promise as something that has to be testable. So before we put a model into production, we backtest it — replay it across real market history and measure how it would have done. The test we hold ourselves to is out-of-sample: how the model performs on stretches of history it never saw while it was being built. It's the difference between a student who's seen the exam in advance and one who hasn't — only the second result tells you anything. That's how we decide which model reflects the real world, rather than one that's merely been tuned to fit the past.
• We override bad data when we have to — and we say so. Before any input is trusted, it's checked automatically. The system watches every feed as it arrives, looking for values that don't hold up — a price that's jumped further than it should, a figure that contradicts another, a number that's gone stale — and it flags anything suspect on its own, rather than waiting for a provider to notice or a client to raise a hand. When a flag turns out to be real and the source is genuinely wrong, or slow to correct itself, our team can step in with a manual correction that overrides the feed — deliberately, temporarily, as a last resort — and we remove it the moment the source is healthy again. We mention this not because it flatters us, but because pretending the inputs are always perfect would be the dishonest thing to do.
• We name our assumptions instead of burying them. An assumption is simply a place where the data runs out and the model has to fill the gap. Some holdings trade rarely — a liquid position might be valued only now and then — so there isn't a fresh price every day, and we use a stand-in close enough to bridge the space until a real number arrives. Every model makes assumptions like these; what we refuse to do is hide them.

Why this matters in wealth management

In wealth management, a risk number isn't an abstract control buried in a report. It's used out loud — by an advisor deciding whether a trade suits a client, by a portfolio manager weighing an exposure, by a compliance team checking a mandate. It shapes the conversation across the table from the person whose money it is.

That raises the bar twice over. The number has to be accurate enough to support the decision, and clear enough to support the conversation. It has to be right not only on the easy holdings but on the difficult ones — the structured product, the illiquid position, the exposure that isn't obvious at a glance — because those are exactly where judgment is hardest. And it has to hold across thousands of portfolios at once, every night, automatically, so the smallest client gets the same rigour as the largest.

Underneath all of it sits the simplest reason of all. In wealth management the downside isn't a statistic. It's someone's retirement, someone's home, someone's plan for their family. The rare, bad outcome is the part a real person actually lives through — so it's the part we refuse to approximate.

A more accurate number doesn't make the future certain — no risk model can promise that. But it greatly improves the odds.