CASE STUDY · 01 · 2023–2025

Reconciliation

How portfolio reporting at Dezerv moved from ~80% to 99.8% accuracy — and why the LLM was the last move, not the first.

Data pipelinesTrustLLM-assisted opsWealthTech
← Back to evidence
The number
80.0%
Portfolio reconciliation accuracy across the customer base.
01

Context

Wealth-tech runs on the user trusting the number on the screen. The biggest single source of broken trust at Dezerv was reconciliation — the silent process that takes raw transactions from custodians, brokers, and exchanges, and turns them into the unified portfolio view the customer actually sees.

When reconciliation breaks, it doesn’t fail loudly. It fails as a wrong cost basis on a holding, a missing dividend, a corporate action applied to the wrong lot, a unit conversion that drifts a percentage point a quarter. Ops gets pulled in to patch by hand. The same class of error shows up again the following week.

◇ Pipeline shift
beforerawparseclassifyreconcileafteringestparseclassifyreconcileLLM (last)
The model came in last. Most of the gains were structural.
02

Approach

The instinct in 2024 was to throw an LLM at it — read the broker statement, write the entry. We resisted that as the first move. Most of the gains were structural.

We rebuilt the pipeline with reconciliation as a first-class object, not a side effect: every exception classified with a stable taxonomy, every correction event durably recorded against the source transaction, every recovery path codified rather than tribal. The state machine made the failure modes legible.

Only after that scaffolding existed did LLMs come into the picture — Gemini and Claude reading edge-case statements where the structured parser failed, suggesting a classification with confidence scores, queueing low-confidence ones for human review. The models worked because the system around them was good. Without that, they would have produced new categories of error faster than ops could catch them.

03

Outcome

Reconciliation accuracy lifted from roughly 80% (under the old ad-hoc pipeline) to 99.8% across the customer base. Ops effort per exception dropped sharply — but more importantly, the same exception class stopped recurring.

The compounding effect: each correction made the system smarter, not just for the user who hit the error, but for every customer whose statement contained the same shape of edge case.

Most of 99.8% was structural. The model just cleaned up the tail.