22Post-Trade Systems

On 28 May 2024 most US securities trades began to settle one business day after the trade date instead of two. The rule that made the change also required brokers to have agreements or policies aimed at completing allocations, confirmations and affirmations by the end of the trade date, and the industry’s plan moved the affirmation cut-off of the central matching service from 11:30 a.m. on the day after the trade to 9:00 p.m. on the trade date itself. For the operations team that fixes a trade whose confirmation does not agree with the firm’s booking, the time available went from a working day to an evening. This chapter builds the systems that decide how many trades need fixing — matching, settlement instructions, reconciliation — and measures what the shorter cycle does to the ones that remain.

22.1 From booked trade to settled trade

Chapter 21 ended with a booked trade in the canonical model. Between booking and settlement (Book 1, chapter 5) the trade must be agreed with the counterparty, instructed to the agents who move the securities and cash, settled, and then checked against what the custodian actually holds. Every step compares two records of the same thing, and every comparison that fails is a piece of manual work with a deadline.

The chapter’s week is a model, and every number in it comes from the model: 500 institutional equity trades a day, executed by eight brokers for five funds, each trade booked in the firm’s canonical model. The brokers’ confirmations carry discrepancies planted at stated rates: a wrong price for 1% of trades, a wrong settlement date for 1%, a wrong account for 1.5%, a wrong quantity for 0.5%, and no confirmation at all for 1%. Three of the eight brokers also round the average price to four decimals, which is not an error at all.

22.2 Confirmation and affirmation

def match(ours: list, theirs: list, keys: tuple, tolerances: dict) -> MatchResult:
    """Pair each trade with the confirmation that agrees on the keys and differs in the
    fewest fields (ties: the first); all within tolerance is a match, else partial."""
    res = MatchResult()
    pool: dict = {}
    for i, t in enumerate(theirs):
        pool.setdefault(tuple(t[k] for k in keys), []).append(i)
    used = set()
    for o in ours:
        cands = [i for i in pool.get(tuple(o[k] for k in keys), []) if i not in used]
        if not cands:
            res.ours_only.append(o)
            continue
        best = min(cands, key=lambda i: (len(_differs(o, theirs[i], tolerances)), i))
        used.add(best)
        diff = _differs(o, theirs[best], tolerances)
        if diff:
            score = 1 - len(diff) / len(tolerances)
            res.partial.append((o, theirs[best], score, diff))
        else:
            res.matched.append((o, theirs[best]))
    res.theirs_only = [t for i, t in enumerate(theirs) if i not in used]
    return res

The key fields must be exact, because they decide which record is compared with which; the tolerances apply to what is compared. Quantities, dates and accounts have no tolerance: a trade for 9 500 shares is not a trade for 9 400. The price is the one field where a tolerance makes sense, because the firm and the broker compute an average price over many fills and may carry it to different precision.

Figure 22.2 shows the two ways to get a tolerance wrong. Too tight, and the rounding convention of three brokers becomes 177 breaks on Monday that nobody needs to fix: a strict match rate of 60.4%. Too loose, and a wrong price of a few cents is matched, and the error is found — if at all — when the cash does not agree. Between the two lies a plateau from half a unit in the fourth decimal to a cent, where the match rate is 95.8% and every remaining break is a real one. The right tolerance is the plateau’s lower end, derived from the precision each counterparty is known to use, and recorded per counterparty in reference data rather than chosen globally.

22.3 Settlement instructions

Once affirmed, each trade becomes an instruction: for Monday’s first trade, a sale of 9 400 shares at $97.586941, a deliver versus payment of $917 317.25 on the settlement date, from the fund’s custody account to the broker’s agent and account taken from the SSI table. Nothing in the instruction is typed; every field comes from the canonical trade or from reference data. That is the point of the SSI table: a wrong account on one confirmation is a break on one trade, but a wrong account in the SSI table is a fail on every trade with that counterparty in that market until someone notices, so SSI changes go through the same approval as the parameter changes of chapter 16 — proposed, checked by a second person, effective from a stated date, never edited in place.

In the model, wrong accounts are the most common discrepancy: 43 of the week’s 138 breaks, against 32 missing confirmations, 27 wrong settlement dates, 26 wrong prices and 10 wrong quantities (Figure 22.3). They are also the kind a firm can remove at the source, by maintaining SSIs once and sharing them with its counterparties instead of letting each side key them.

22.4 Reconciliation and breaks

def reconcile(ours: dict, theirs: dict, groups: dict | None = None,
              opened: float = 0.0) -> list[Break]:
    """Compare quantities by key; `groups` maps a custodian key to several of ours
    (a block the firm allocated)."""
    ours, theirs = dict(ours), dict(theirs)
    for tk, oks in (groups or {}).items():
        total = sum(ours.pop(k, 0) for k in oks)
        ours[tk] = ours.get(tk, 0) + total
    out = []
    for k in sorted(set(ours) | set(theirs), key=str):
        a, b = ours.get(k), theirs.get(k)
        if a != b:
            x, y = (a if a is not None else 0), (b if b is not None else 0)
            out.append(Break(classify(a, b), k, x, y, opened))
    return out

The difficulty of reconciliation is rarely the comparison; it is the keys. The custodian may report one position where the firm holds five allocations (a one-to-many group), a cash movement may be the sum of a day’s trades (an aggregate), and identifiers may differ between the two sides, so the reference data of chapter 6 decides whether a difference is real. A break then needs three more things before it is useful: a kind (missing on one side, a quantity difference), an owner, and an age.

22.5 Operating under a short settlement cycle

The model’s operations team is three people. Breaks are worked largest value first, each taking a random time whose average depends on the kind (30 minutes for a settlement date, 45 for a price or a quantity, an hour for an account, an hour and a half to chase a missing confirmation). The window is where the two cycles differ. Under T+2 the model gives the team the next working day, 08:00 to 17:00, before a trade can no longer be settled on time; under T+1 it gives the evening of the trade date, 17:00 to the 21:00 affirmation cut-off. These windows are the model’s choices, set on the cut-offs quoted in the hook; a real team also works during the trading day, which helps both cycles equally.

def resolve(brks: list[dict], cycle: str, seed: int = 0,
            staff: int = STAFF) -> tuple[list, list]:
    """The team fixes breaks, largest value first, inside the window; (fixed, failed)."""
    rng = np.random.default_rng(seed)
    start, end = WINDOWS[cycle]
    free = [start] * staff
    order = sorted(brks, key=lambda b: -b["trade"]["qty"] * b["trade"]["price"])
    fixed, failed = [], []
    for b in order:
        k = int(np.argmin(free))
        took = float(rng.exponential(FIX_MINUTES[b["kind"]])) / 60.0
        if free[k] + took <= end:
            free[k] += took
            fixed.append(b)
        else:
            failed.append(b)
    return fixed, failed

The breaks are the same under both cycles — they come from the confirmations, not the calendar — but the work they need does not fit in the evening. The week’s breaks need about 26 hours of work a day on average; the next working day gives three people 27 hours, the evening 12. Under T+2 ten trades fail in the week, $2.74 million of value; under T+1 forty-seven fail, $19.17 million, and the Friday reconciliation finds six times as many position breaks (Table 22.1). A failed trade is not lost — it settles later — but the fund does not have the securities or the cash it expected, the position service of chapter 17 must carry settled and unsettled positions separately, and some markets charge for the fail: Book 2, chapter 5, describes the fails charge in the Treasury market.

There are two ways back to the fails of the longer cycle, and Figure 22.4 compares them. The first is people: with seven in operations instead of three the evening absorbs the work, and the week’s fails fall to 11. The second is fewer breaks: halving the rate of wrong accounts and missing confirmations — SSIs maintained once and shared, allocations sent to the broker as soon as they are decided — brings the fails to 13 with the same three people. The second is cheaper and it lasts, which is why the move to T+1 was prepared as much in reference data and allocation workflows as in staffing.

The general lesson is the one of chapter 21: post-trade cost is set upstream. Every break the pipeline creates is paid for by a person against a deadline, and a shorter cycle shortens the deadline without changing the number of breaks. The measure to watch is the share of trades that go from booking to settlement untouched — the straight-through rate — by counterparty and by kind of break, together with the age of what is left.

22.6 Tutorial: a week of confirmations under two cycles

22.7 Build: post-trade

22.8 Exercises

22.9 Problem: One Evening Instead of a Day

22.10 Interview questions