# Anton Batiaev

> VP Product & Engineering at Capital.com, running the trading-platform tribe;
> previously Revolut, CTO at Vega and Nevis, and Deutsche Bank. Ten years
> building execution, derivatives pricing, margin and risk systems. Also builds
> Fintecy (read-only portfolio and P&L aggregation) and SHIP (a typed knowledge
> graph for engineering teams).

This site hosts a free knowledge base — options, derivatives risk, market data,
market making and execution, AI engineering (harnesses, agentic workflows,
knowledge bases) and a reading list — plus a set of finance calculators. Everything runs client-side;
there are no accounts and no tracking beyond analytics.

## Free tools

- [Options P&L calculator — payoff, Greeks, breakevens | Anton Batiaev](https://batiaev.com/tools/options-pnl): Free options strategy calculator: exact expiry payoff, Black-Scholes and Black-76 P&L before expiry, Greeks, breakevens and shareable links. No signup, runs in your browser.
- [Dynamic hedging simulator — what the option premium actually buys](https://batiaev.com/tools/hedging): Sell an option, delta-hedge it to expiry and watch the premium leave through the hedge. Set the volatility you sold at against the volatility the market delivers. Free, runs in your browser.
- [Volatility smile from a quote board — implied vol, skew, curvature](https://batiaev.com/tools/smile): Enter bid and ask for a strip of strikes and get an implied volatility for each side, a fitted smile, and the strikes the market prices clear of its own curve. Free, runs in your browser.
- [How much is enough? — retirement Monte Carlo across ISA, LISA and pension](https://batiaev.com/tools/retirement): Model a UK retirement plan across an ISA, a LISA and a pension: contributions, growth, and spending it down. A thousand return paths give the chance the money lasts, the spending it could support, and where a plan fails. Free, runs in your browser.
- [Employed vs self-employed vs limited company — UK take-home 2026/27](https://batiaev.com/tools/take-home): Compare the same income as an employee, a sole trader, through your own limited company, or via an umbrella. 2026/27 income tax, Class 1 and Class 4 NI, corporation tax and dividend tax. Free, runs in your browser.
- [Startup vs hypergrowth vs enterprise — compensation comparison](https://batiaev.com/tools/offer): Compare compensation shapes, not salaries. Price a startup grant, a scale-up RSU package and an enterprise base as distributions — downside, probability-weighted and upside — after dilution and UK tax.

## Knowledge base

### Options

The concepts every strategy assumes, then one page per structure — each with a live payoff chart you can edit and open in the calculator.

- [What an option actually is](https://batiaev.com/learn/options/basics): Calls, puts, strike, expiry and the difference between intrinsic and extrinsic value — the vocabulary everything else assumes.
- [The Greeks, without the calculus](https://batiaev.com/learn/options/greeks): Delta, gamma, vega and theta as four questions about the same position, and which one actually kills you.
- [Implied volatility is the price](https://batiaev.com/learn/options/volatility): Why an option's quoted premium is really a volatility number, and what the smile is telling you.
- [Long call](https://batiaev.com/learn/strategies/long-call): The simplest bullish option: defined risk, unlimited upside, and a bill for time decay every day you are wrong.
- [Long put](https://batiaev.com/learn/strategies/long-put): Downside exposure with a floor on the loss — the cleanest way to be short without unlimited risk.
- [Covered call](https://batiaev.com/learn/strategies/covered-call): Own the underlying, sell someone the right to take it from you above a set price, and keep the premium either way.
- [Cash-secured put](https://batiaev.com/learn/strategies/cash-secured-put): Get paid to bid below the market, with the cash set aside to buy if you are filled.
- [Bull call spread](https://batiaev.com/learn/strategies/bull-call-spread): Buy a call, sell a higher one. Cheaper than the call alone, with the upside capped at the short strike.
- [Bear put spread](https://batiaev.com/learn/strategies/bear-put-spread): The same trade pointed down: buy a put, sell a lower one.
- [Long straddle](https://batiaev.com/learn/strategies/long-straddle): Buy the call and the put at the same strike. A bet on movement, indifferent to direction.
- [Short strangle](https://batiaev.com/learn/strategies/short-strangle): Sell an out-of-the-money put and call. Collect premium while nothing happens — and carry an undefined tail.
- [Iron condor](https://batiaev.com/learn/strategies/iron-condor): A short strangle with both tails bought back. Same idea, defined risk, smaller credit.
- [Long butterfly](https://batiaev.com/learn/strategies/long-butterfly): A cheap, narrow bet that the underlying finishes at a particular price.
- [Collar](https://batiaev.com/learn/strategies/collar): Hold the asset, buy a protective put, and sell a call to pay for it.

### Risk

How the positions above are margined and measured — the systems side, which is the part I actually built.

- [SPAN, and why your margin is not what you expected](https://batiaev.com/learn/risk/span): How exchange portfolio margining actually works: the sixteen-scenario risk array, spread charges, and the short option minimum that catches people out.
- [VAR, and what it does not tell you](https://batiaev.com/learn/risk/var-and-es): Value at Risk in one sentence, the three ways to compute it, the reason it is not a coherent risk measure, and why regulators moved to Expected Shortfall.
- [DV01 and the shape of rate risk](https://batiaev.com/learn/risk/dv01): The one number a rates desk actually watches, how it relates to duration and convexity, and why a single parallel shift is not enough.
- [Dynamic hedging, and where the premium goes](https://batiaev.com/learn/risk/dynamic-hedging): Sell an option, hedge it to expiry, and watch the premium leave through the hedge — why the price you collect is the price of the gamma you are short.

### Markets

How prices arrive and how orders meet them — market data, market making and execution, from the side of the systems that run them.

- [Market data is a claim about the past](https://batiaev.com/learn/markets/market-data): Ticks, books and the plumbing between an exchange and a price on screen: normalisation, conflation, gaps, staleness, and what a composite price quietly hides.
- [Market making is inventory management](https://batiaev.com/learn/markets/market-making): Where a spread comes from, why a market maker skews rather than widens, the reservation price, adverse selection measured by markouts, and when to hedge rather than hold.
- [Execution, from order to fill](https://batiaev.com/learn/markets/execution): Order types, smart order routing and liquidity aggregation, the latency budget, pre-trade risk checks, and how to measure what execution actually cost.

### AI engineering

Building with models and agents in production: the harness around the model, the workflows that keep it honest, and the knowledge it reads and writes.

- [The harness is most of the product](https://batiaev.com/learn/ai/harness): A model is one component. The context it is given, the tools it may call, the permissions around them and the checks after them decide whether an agent is useful.
- [Agentic workflows that hold up](https://batiaev.com/learn/ai/agentic-workflows): Plan, act, verify — and why the verify step has to be something the model cannot talk its way past: tests, type-checks, property checks, and a human at the irreversible step.
- [Knowledge bases: typed beats retrieved](https://batiaev.com/learn/ai/knowledge-bases): Why retrieval over a pile of documents fails quietly, what hybrid search fixes, and why goals, decisions and artefacts work better as typed nodes with provenance.
- [Product engineering when code is cheap](https://batiaev.com/learn/ai/product-engineering): When an agent can write the diff, the scarce work moves to the spec, the verification and the taste encoded in rules — and the line between product and engineering moves with it.

### Library

Where to go when this runs out — one page each for books, series and films.

- [Books](https://batiaev.com/learn/library/books): The reference texts worth owning, the narratives worth reading, and where to look when both run out.
- [TV series](https://batiaev.com/learn/library/series): Longer form gets closer to the texture of the job than any film has managed — desk culture, hierarchy, and the parts nobody puts in a prospectus.
- [Films](https://batiaev.com/learn/library/films): Which films get the culture right even when they bend the mechanics, and which ones to watch knowing exactly what they are.

## Optional

- [CV](https://batiaev.com/cv)
- [Advisory](https://batiaev.com/advisory): Selective advisory for founders and investors: technical diligence, architecture de-risking, and fractional CTO work in regulated fintech.

---

# Full text

The complete prose of the knowledge base follows, so this file can be read in
one fetch. Interactive charts are omitted; each page has a live payoff chart
driven by the same pricing model as the calculator.

## What an option actually is

Source: https://batiaev.com/learn/options/basics
Topics: beginner, calls and puts, intrinsic value, theta

Calls, puts, strike, expiry and the difference between intrinsic and extrinsic value — the vocabulary everything else assumes.

An option is a right, not an obligation, to trade something at a fixed price
before a fixed date. That is the whole definition. Everything else — the
Greeks, the smile, the strategies — is bookkeeping on top of it.

## Calls and puts

A **call** gives you the right to buy at the strike. You want the price up.
A **put** gives you the right to sell at the strike. You want the price down.

Whoever sold you that right has the mirror position and an obligation rather
than a choice. This asymmetry is the entire product: the buyer's loss is capped
at the premium, and the seller's is not.


Move the spot slider on that chart. Below the strike the line is flat — you
simply do not exercise, and the premium is gone. Above it the payoff turns and
climbs at the same rate as the underlying. The kink sits exactly on the strike,
which is why option payoffs are drawn with corners rather than curves.

## Strike, expiry, premium

Three numbers define a contract.

- **Strike** — the price you may transact at.
- **Expiry** — the date the right lapses.
- **Premium** — what the right costs.

A contract usually covers 100 shares, so a premium quoted at 3.02 costs £302.
The calculator calls this the multiplier, and forgetting it is the most common
arithmetic error in option trading.

## Moneyness

An option is **in the money** if exercising it right now would be worth
something, **at the money** if the strike is roughly spot, and **out of the
money** if exercising would be pointless. A call at a 90 strike with spot at 100
is 10 in the money; the same call with spot at 80 is 10 out of the money and
worth only whatever chance remains.

## Intrinsic and extrinsic value

Premium splits cleanly into two parts.

**Intrinsic value** is what the option is worth if it expired this second —
`max(spot − strike, 0)` for a call. It cannot be negative, because you would
simply not exercise.

**Extrinsic value** is everything else: the price of the time remaining and the
uncertainty in it. It is the entire premium of an out-of-the-money option, and
it decays to nothing by expiry with mathematical certainty.

That decay is the central fact of being long options. You are paying, every
day, for the possibility that you are right. Set the days-elapsed slider on the
chart above and watch the pre-expiry line sag towards the hard expiry line —
that gap is extrinsic value draining away.

## Why the expiry line has corners

Look at the two lines on the chart. The solid one is the payoff at expiry:
piecewise linear, kinked exactly at the strike, because at expiry an option is
worth its intrinsic value and nothing else.

The dashed one is the modelled value before expiry, and it is smooth. It sits
above the expiry line everywhere, and the distance between them is the
extrinsic value you still own. Both lines meet at expiry. Every options
strategy is, in some sense, a bet about how those two lines converge.

## What comes next

The Greeks are the four sensitivities that describe how the dashed line moves
when something changes — spot, time, or volatility. They are less intimidating
than the notation suggests, and they are the subject of the next page.

---

## The Greeks, without the calculus

Source: https://batiaev.com/learn/options/greeks
Topics: greeks, delta, gamma, vega, theta

Delta, gamma, vega and theta as four questions about the same position, and which one actually kills you.

The Greeks are four questions about the same position, each asking what happens
to its value when one thing moves and everything else stands still.

You do not need the calculus to use them. You need to know which one is
currently your problem.

## Delta — how much like the underlying is this?

Delta is the change in the option's value for a one-point move in the
underlying. A call runs from 0 (hopelessly out of the money) to 1 (so deep in
the money it behaves like stock). A put runs from 0 to −1.

The useful reading is as **equivalent position size**. A 0.4-delta call on 100
shares behaves, for small moves, like owning 40 shares. Sum the deltas across a
book and you have your net directional exposure in a single number — which is
exactly what a trading desk's risk system reports.


## Gamma — how fast is delta changing?

Gamma is the rate of change of delta. High gamma means your directional
exposure is unstable: the position becomes rapidly more long as the price rises
and more short as it falls.

Gamma is largest at the money and close to expiry. This is why the last day of
a contract's life is the dangerous one — a position that was comfortably hedged
in the morning can be badly wrong by the afternoon without the underlying doing
anything dramatic.

Long options are long gamma, which is pleasant: the position gets longer as it
wins. Short options are short gamma, which is the opposite, and it is the
mechanism by which sold options produce sudden large losses.

## Theta — what does waiting cost?

Theta is the value lost per day from time passing alone. It is negative when
you are long options and positive when you are short.

Theta and gamma are two sides of one trade. Being long gamma — profiting from
movement — is paid for with negative theta. Being short gamma earns theta and
sells you the risk. There is no position that is long gamma and long theta;
if you think you have found one, check the trade again.

## Vega — what if the market changes its mind about risk?

Vega is the change in value for a one-point move in implied volatility. It is
not actually a Greek letter, which tells you something about how the vocabulary
grew.

Vega matters more than most people expect. You can be exactly right about
direction and still lose, because implied volatility collapsed after the event
you were positioned for. This is routine around earnings: the move happens, and
the option holder loses anyway.


A straddle is nearly pure vega at the money — flat delta, and its value is
almost entirely a view on volatility. Drag the volatility slider and watch the
pre-expiry line lift and fall while the expiry line stays exactly where it is.
That difference is what you are actually trading.

## Which one kills you

In roughly this order:

1. **Gamma**, because it turns a manageable position into an unmanageable one
   without warning, and it is worst exactly when you have least time to react.
2. **Vega**, because it moves against you at the same moment as everything
   else — volatility rises when markets fall, so a hedge gets more expensive
   precisely when you want it.
3. **Theta**, which is at least honest. It takes a predictable amount every
   day and never surprises anyone.
4. **Delta**, which is the risk everyone thinks about and the one most easily
   hedged.

The calculator reports all four aggregated across a whole position, which is
the only level at which they are useful — individual leg Greeks rarely tell you
what you want to know.

---

## Implied volatility is the price

Source: https://batiaev.com/learn/options/volatility
Topics: volatility, implied volatility, smile, vega, pricing

Why an option's quoted premium is really a volatility number, and what the smile is telling you.

Black-Scholes takes six inputs: spot, strike, time, rate, carry and volatility.
Five of those are observable. Volatility is not — nobody knows what the future
holds.

So the market inverts the problem. It quotes a price, and you solve backwards
for the volatility that price implies. That number is **implied volatility**,
and it is the only genuinely negotiable input. Everything else is arithmetic.

## Options are quoted in volatility

On a professional desk, options are not really priced in currency. They are
priced in vol, and the currency figure falls out at the end. Two options on
different underlyings at different strikes with different premiums are directly
comparable once expressed as implied volatility — which is the whole reason
the convention exists.

When someone says an option "looks expensive", they almost never mean the
premium. They mean the implied volatility is high relative to what they expect
the underlying to actually do.

## Implied versus realised

**Realised volatility** is what the underlying did, measured after the fact.
**Implied volatility** is what the market is charging for it in advance.

The gap between them is the trade. Selling options is a bet that implied
exceeds realised; buying them is the reverse. Implied is usually a little
higher, which is the risk premium option sellers earn — and which is also why
selling volatility wins most of the time and occasionally loses catastrophically.


Move the volatility slider on that strangle. The expiry line does not budge —
at expiry only the spot price matters. But the pre-expiry line moves a great
deal, because the position's mark-to-market is a pure volatility view until the
last day. Short volatility positions are marked against you long before they
are settled against you.

## The smile

Black-Scholes assumes one volatility for all strikes. The market disagrees.

Plot implied volatility against strike and you get a curve, not a line: out-of-
the-money puts trade at higher implied volatility than at-the-money options,
and often higher than out-of-the-money calls. The shape is called the
**volatility smile**, or the **skew** when it leans one way.

It exists because the model's assumptions are wrong in a specific direction.
Returns are not normally distributed; crashes are larger and more frequent than
the maths allows, and they are correlated with everyone wanting protection at
the same time. The smile is the market pricing in what the model leaves out.

Equity indices show a pronounced downside skew for exactly this reason. FX
tends toward a more symmetric smile, because either currency can be the one
that collapses.

## What this means in practice

- A single volatility number for a multi-strike position, which is what this
  site's calculator uses, is a simplification. It is fine for understanding
  shape and wrong for pricing a real trade against a real surface.
- If you are quoted a price, ask what vol it implies before deciding whether it
  is expensive.
- If a strategy looks like free money, you are usually short a tail that is not
  in the model. The smile exists precisely because those tails are real.

I spent a good part of my time at Otkritie building the pricing engine that
produced these curves for the desk — implied vol, the smile, and the Greeks
that fall out of them, across index, commodity, FX and single-stock options.
The lesson that stuck: the model is a language for expressing a view, not a
source of truth. It is most dangerous when it agrees with you.

---

## Long call

Source: https://batiaev.com/learn/strategies/long-call
Topics: directional, long premium, beginner, theta

The simplest bullish option: defined risk, unlimited upside, and a bill for time decay every day you are wrong.

**The view:** Up, and soon enough to beat theta.

## When it fits

You want exposure to a rise without putting up the cash for the shares, and you can name a date by which you expect it. The premium is the most you can lose, which makes this the usual first option anyone buys.

## What goes wrong

- Time decay works against you every day, and accelerates as expiry approaches.
- Being right about direction but late is the same as being wrong.
- A fall in implied volatility can lose you money even if the underlying rises.

---

## Long put

Source: https://batiaev.com/learn/strategies/long-put
Topics: directional, long premium, hedging, beginner

Downside exposure with a floor on the loss — the cleanest way to be short without unlimited risk.

**The view:** Down, or a hedge against something you own.

## When it fits

Either an outright bearish view, or insurance on a holding you do not want to sell. As a hedge it is expensive precisely when you most want it, because volatility rises as markets fall.

## What goes wrong

- Puts are usually priced above their theoretical value, because everyone wants the same insurance.
- The premium is a certain cost against an uncertain payoff.
- Time decay again — a slow decline can still lose money.

---

## Covered call

Source: https://batiaev.com/learn/strategies/covered-call
Topics: income, short premium, assignment, beginner

Own the underlying, sell someone the right to take it from you above a set price, and keep the premium either way.

**The view:** Flat to mildly up, and you are content to sell at the strike.

## When it fits

You hold the asset, you would be happy selling at a particular level, and you want to be paid for the wait. Popular as an income trade, and reasonable when you genuinely mean the sell.

## What goes wrong

- You keep the entire downside and cap the upside — the payoff is the opposite shape to the one people assume they are buying.
- A sharp rally means you sell at the strike and watch it keep going.
- The premium is small compensation for a large move in either direction.

---

## Cash-secured put

Source: https://batiaev.com/learn/strategies/cash-secured-put
Topics: income, short premium, assignment, beginner

Get paid to bid below the market, with the cash set aside to buy if you are filled.

**The view:** You want to own it, but lower.

## When it fits

You are a willing buyer at a price below spot. Selling the put pays you to wait, and if it is assigned you buy at a level you already chose.

## What goes wrong

- Identical payoff to a covered call — the downside is the whole move to zero, less the premium.
- You get assigned exactly when you least want to buy, because the price fell for a reason.
- The cash is tied up for the life of the trade.

---

## Bull call spread

Source: https://batiaev.com/learn/strategies/bull-call-spread
Topics: directional, spread, defined risk

Buy a call, sell a higher one. Cheaper than the call alone, with the upside capped at the short strike.

**The view:** Up, but only so far.

## When it fits

You have a target rather than a hope. Selling the upper strike funds part of the position and cuts the amount time decay can take from you.

## What goes wrong

- The cap is real: everything above the short strike belongs to someone else.
- Both legs have to be closed, so spreads cost more to trade than they look.
- Maximum profit only arrives at expiry, not on the way there.

---

## Bear put spread

Source: https://batiaev.com/learn/strategies/bear-put-spread
Topics: directional, spread, defined risk

The same trade pointed down: buy a put, sell a lower one.

**The view:** Down, to a level you can name.

## When it fits

A bearish view with a floor in mind — support, a valuation, a level you do not expect to break. Cheaper than the outright put for the same reason.

## What goes wrong

- Capped at the lower strike, so a crash pays no more than a slide.
- Still a debit: you can lose the whole premium.
- Short put legs can be assigned early if they go deep in the money.

---

## Long straddle

Source: https://batiaev.com/learn/strategies/long-straddle
Topics: volatility, long premium, vega, events

Buy the call and the put at the same strike. A bet on movement, indifferent to direction.

**The view:** Something is about to happen. No idea which way.

## When it fits

Ahead of a binary event — earnings, a ruling, a launch — where the size of the move matters more than its sign.

## What goes wrong

- You are buying volatility that is already priced for the event, so the move has to beat expectations, not just happen.
- Implied volatility usually collapses the moment the news lands, which can lose money even on a correct call.
- Two premiums to recover means the breakevens are further out than they feel.

---

## Short strangle

Source: https://batiaev.com/learn/strategies/short-strangle
Topics: volatility, short premium, vega, margin, tail risk

Sell an out-of-the-money put and call. Collect premium while nothing happens — and carry an undefined tail.

**The view:** Quiet, and quieter than the market is pricing.

## When it fits

When implied volatility looks expensive relative to what you expect to be realised. It wins most of the time, which is exactly what makes it dangerous.

## What goes wrong

- Losses are unbounded on the upside and very large on the downside.
- A high win rate hides the shape: many small gains and occasional catastrophic ones.
- Margin requirements expand as the position moves against you, forcing you out at the worst moment.

---

## Iron condor

Source: https://batiaev.com/learn/strategies/iron-condor
Topics: volatility, short premium, defined risk, margin

A short strangle with both tails bought back. Same idea, defined risk, smaller credit.

**The view:** Range-bound, and you want to sleep.

## When it fits

The disciplined version of selling volatility. The wings cost part of the premium and convert an unbounded loss into a known one.

## What goes wrong

- The maximum loss is usually several times the credit received.
- Four legs means four lots of spread and commission.
- It needs the underlying to stay inside the range at expiry, not merely to pass through it.

---

## Long butterfly

Source: https://batiaev.com/learn/strategies/long-butterfly
Topics: volatility, defined risk, pinning

A cheap, narrow bet that the underlying finishes at a particular price.

**The view:** It pins, right here.

## When it fits

A precise view on where something settles, with very little capital at risk. The payoff peak is sharp and only exists at expiry.

## What goes wrong

- The profit zone is narrow and the peak is only reached at expiry.
- Three strikes, four contracts — execution costs eat a low-premium trade.
- Usually expires worthless, which is the price of the asymmetry.

---

## Collar

Source: https://batiaev.com/learn/strategies/collar
Topics: hedging, income, concentrated position

Hold the asset, buy a protective put, and sell a call to pay for it.

**The view:** I want to keep this, but not the tail risk.

## When it fits

A concentrated holding you cannot or will not sell — vested shares being the obvious case. The short call funds the insurance, sometimes entirely.

## What goes wrong

- You give up the upside above the call strike, which on a concentrated position is often the whole reason you held it.
- Selling calls against shares you cannot deliver creates a real problem if assigned.
- For employee shares, the tax treatment of a collar is rarely as simple as the payoff diagram.

---

## SPAN, and why your margin is not what you expected

Source: https://batiaev.com/learn/risk/span
Topics: margin, span, portfolio margin, short premium, exchange, risk systems, measurement

How exchange portfolio margining actually works: the sixteen-scenario risk array, spread charges, and the short option minimum that catches people out.

Sell a naked put and your broker asks for a large deposit. Buy a further
out-of-the-money put against it, turning the position into a spread with a
known worst case, and the requirement collapses. Nothing about your view
changed. What changed is that the margin system can now see the hedge.

That system, on most futures and options exchanges, is **SPAN** — Standard
Portfolio Analysis of Risk, introduced by the CME in 1988 and licensed by
exchanges worldwide. It is not complicated, but it is almost never explained,
so people learn its behaviour by being surprised by it.

## The idea

Strategy-based margining looks at each position and applies a rule. Portfolio
margining asks a different question: **across a set of plausible market moves,
what is the worst this whole portfolio does in one day?** That number, roughly,
is your margin.

Because it values the portfolio as a whole, offsetting positions offset. A
long call and a short call at a higher strike are not two margin charges; they
are one spread with a capped loss.

## The risk array

The exchange publishes, for each contract, two parameters: a **price scan
range** — how far it thinks the underlying can move in a day — and a
**volatility scan range**. SPAN then revalues your portfolio under sixteen
scenarios built from those two numbers.

| # | Underlying move | Volatility | Weight |
|---|---|---|---|
| 1–2 | Unchanged | Up / down | 100% |
| 3–4 | +⅓ range | Up / down | 100% |
| 5–6 | −⅓ range | Up / down | 100% |
| 7–8 | +⅔ range | Up / down | 100% |
| 9–10 | −⅔ range | Up / down | 100% |
| 11–12 | +1 range | Up / down | 100% |
| 13–14 | −1 range | Up / down | 100% |
| 15 | +2 ranges | Unchanged | 35% |
| 16 | −2 ranges | Unchanged | 35% |

Fourteen scenarios walk the price across the scan range in thirds, each paired
with volatility rising and falling. The last two are the tail: a move of twice
the scan range, counted at a fraction — conventionally 35% — because the
exchange wants some charge for a crash without margining every account as
though one is due tomorrow.

Your **scan risk** is the worst loss across those sixteen rows. Note what this
implies: the volatility legs mean a short option position can be charged its
worst case on a day the underlying does not move at all.


Drag the volatility slider on that strangle and watch the pre-expiry line drop
while the expiry line stays put. Rows 1 and 2 of the risk array are exactly
that move. This is why short volatility positions get margin calls in quiet
markets — the scan found the vol-up scenario, not a price move.

## The parts nobody mentions

Scan risk is the headline, but the total is built from four more pieces.

**Intra-commodity spread charge.** SPAN treats all months of a contract as one
underlying, which is generous — a long March and short June future nets to
almost nothing. But the months do not move identically, so a charge is added
back for calendar spread risk. It is small, and it surprises people who
expected a perfectly hedged spread to be free.

**Inter-commodity spread credit.** Related products get a discount for
offsetting. Long crude against short heating oil is genuinely less risky than
either alone, and the exchange grants a percentage credit for recognised pairs.

**Delivery or spot month charge.** Contracts near expiry behave badly —
liquidity thins and squeezes happen — so an extra charge applies as delivery
approaches.

**Short option minimum.** The one that catches people. A portfolio of deep
out-of-the-money short options can scan to almost no risk, because in all
sixteen scenarios the options stay worthless. SPAN refuses to believe this and
imposes a floor per short contract. Sell enough far-out-of-the-money options
and your margin is set entirely by this minimum, with the scan irrelevant.

The total is roughly:

```
margin = max(scan risk + intra-commodity charge − inter-commodity credit,
             short option minimum)
             + delivery charge
```

## What this means when you trade

- **Defining your risk cuts your margin, often dramatically.** Buying the wing
  on a short position costs premium and buys back a large part of the deposit.
  This is most of the reason iron condors exist rather than strangles.
- **Margin is not static.** The exchange raises scan ranges when realised
  volatility rises — which is precisely when your position is already losing.
  Requirements expand into a falling market, and forced liquidation is a
  liquidity event, not a solvency one. That mechanism has ended more accounts
  than bad directional calls.
- **Check the short option minimum before scaling.** A strategy that looks
  capital-efficient at ten contracts may be floored at a hundred.
- **Your broker may add to it.** SPAN is the exchange's number. Brokers
  routinely apply a multiplier on top, and retail multipliers can be
  substantial.

## Notes from building one

I built the risk and margin engine at Otkritie — SPAN portfolio margining
across futures and options on index, commodity, FX and single stocks, feeding
a real-time engine handling over a million updates a second for 400,000
investors. Three things I did not expect going in.

The arithmetic is the easy part. Sixteen revaluations per contract is nothing.
The hard part is the **reference data**: scan ranges, tiers, spread definitions
and credit rates change, they arrive as files on a schedule, and a stale
parameter produces a confidently wrong number rather than an error.

The second is that **the option pricing model inside the margin calculation has
to match the one on the trading screen**, or clients see a margin requirement
that disagrees with their own P&L and — reasonably — do not trust either.

The third is that margin is a **real-time obligation, not a report**. It has to
be right on every tick, because it gates whether an order can be placed at all.
That constraint, more than the mathematics, is what makes a margin engine an
engineering problem.

## Beyond SPAN

Exchanges are migrating from the original algorithm to **SPAN 2**, which
combines a historical-value-at-risk model with a stress component and handles
liquidity and concentration more explicitly. The intuition above still holds —
scenarios, portfolio offsets, and add-ons for the things a scenario grid
misses. The parameters change; the shape of the answer does not.

For the authoritative detail, go to the exchange's own methodology
documentation rather than a textbook. It is free, precise, and updated when the
rules change.

---

## VAR, and what it does not tell you

Source: https://batiaev.com/learn/risk/var-and-es
Topics: var, expected shortfall, risk measure, basel, tail risk, risk systems, measurement

Value at Risk in one sentence, the three ways to compute it, the reason it is not a coherent risk measure, and why regulators moved to Expected Shortfall.

**Value at Risk** answers one question: over some horizon, at some confidence,
how much could I lose?

A 1-day 99% VAR of £1m means that on 99 days out of 100 you expect to lose less
than £1m. It says nothing whatsoever about the hundredth day, and that omission
is the entire debate.

## Three ways to compute it

**Historical simulation.** Take the last few hundred days of market moves,
apply each one to today's portfolio, sort the resulting P&Ls, and read off the
percentile. No distributional assumption, which is its great virtue. Its great
weakness is that it can only produce a crisis it has already seen — a
two-year window that contains no crash will price no crash.

**Variance–covariance.** Assume returns are normally distributed, compute the
portfolio's volatility from a covariance matrix, and multiply by the
appropriate z-score. Fast, analytic, and wrong in a specific direction:
financial returns have fatter tails than the normal distribution, so this
method systematically understates exactly the losses you built it to measure.
It also handles options badly, because a linear approximation of a convex
payoff breaks down at the sizes that matter.

**Monte Carlo.** Simulate many paths from a model, revalue the portfolio under
each, take the percentile. Flexible and the only practical choice for genuinely
non-linear books. Expensive, and no more truthful than the model generating the
paths.

## Scaling, and a common misuse

A 1-day VAR is often scaled to ten days by multiplying by √10. That step
assumes returns are independent and identically distributed. They are not:
volatility clusters, and bad days arrive in runs. Square-root-of-time scaling
therefore understates multi-day risk precisely during the episodes it is
supposed to capture.

## Why VAR is not a coherent risk measure

There is a formal definition of what a sensible risk measure should do, set out
by Artzner and co-authors. One requirement is **subadditivity**: combining two
portfolios should never produce more risk than the sum of their parts, because
diversification cannot be harmful.

VAR fails this. It is possible to construct two positions whose combined VAR
exceeds the sum of the individual VARs — typically involving discrete,
low-probability large losses that individually sit just outside the confidence
threshold and together fall inside it. A risk measure that can penalise
diversification is not merely inelegant; it creates an incentive to concentrate.

VAR has a second, more everyday failure. It is a **threshold**, so it is blind
to everything past it. Two portfolios can have identical 99% VAR while one
loses £1.1m on the worst day and the other loses £90m. Selling far
out-of-the-money options is the classic way to report a flattering VAR while
accumulating precisely the risk the number cannot see.

## Expected Shortfall

**Expected Shortfall** — also called CVaR or conditional VAR — is the average
loss *given* that you are in the tail beyond the VAR threshold.

> VAR asks how bad things get before the worst 1%. ES asks how bad the worst 1%
> actually is.

ES is subadditive and coherent. It cannot be gamed by pushing risk just past a
percentile, because it integrates over everything out there. This is why the
Basel Committee's Fundamental Review of the Trading Book replaced 99% VAR with
**97.5% Expected Shortfall** for market risk capital. The confidence level
dropped because, for a normal distribution, 97.5% ES lands close to 99% VAR —
so the change alters what is measured more than how much capital results.

## The catch with ES

ES is harder to backtest. VAR backtesting is simple: count the days the loss
exceeded the forecast. At 99% over 250 days you expect around two or three
exceptions, and Basel's traffic-light framework escalates as the count rises —
a straightforward, auditable test.

ES has no equivalent clean test, because it is a conditional average rather
than a threshold. Verifying it needs indirect approaches, and this is a live
practical problem rather than a theoretical footnote: a number you cannot
readily validate is a number that can drift.

## What both miss

Neither measure covers the risks that actually close firms.

- **Liquidity.** Both assume you can exit at the marked price. In a crisis you
  cannot, and the mark is the first thing to become fictional.
- **Correlation breakdown.** Diversification is priced from history.
  Correlations converge towards one in a crash, exactly when the model is
  relying on them not to.
- **Funding.** Losing money and being unable to meet a margin call are
  different failures. The second is what forces liquidation, and it does not
  appear in either measure.

LTCM had a sophisticated risk framework. What ended it was a correlated move
in positions assumed independent, met by margin calls that could not be funded.
The mathematics was not the weak point.

## Building one

At Revolut I owned the greenfield risk system behind the wealth and trading
platform — mark-to-market, collateral and variation margin, VAR and Expected
Shortfall, DV01, Greeks, book value and accruals, across fixed income, FX and
interest-rate derivatives, spot FX, crypto and commodities.

The lesson that transferred to everything since: **the number is the easy part,
and the data lineage is the whole job.** A VAR figure is only as good as the
position feed, the price history and the corporate-action handling underneath
it. Most of what looked like model risk turned out, on inspection, to be a
stale price or a position that had been booked twice.

The second lesson is that a risk number nobody can explain gets ignored. If a
trader cannot see which position drove the move, the report becomes decoration.
Attribution — being able to decompose the number back to its causes — matters
more for whether a risk system changes behaviour than the sophistication of
the model producing it.

---

## DV01 and the shape of rate risk

Source: https://batiaev.com/learn/risk/dv01
Topics: dv01, duration, convexity, rates, hedging, risk systems, measurement

The one number a rates desk actually watches, how it relates to duration and convexity, and why a single parallel shift is not enough.

Equity desks talk in delta. Rates desks talk in **DV01** — the dollar value of
a basis point. It is the change in a position's value when the relevant yield
moves by one hundredth of a percent.

That is all it is. A bond with a DV01 of £850 gains roughly £850 if yields fall
one basis point, and loses roughly £850 if they rise one. You will also see it
as **PV01** or **BPV**; for most purposes the distinction is not worth arguing
about.

## Why a basis point

Because it makes unlike things comparable. A ten-year gilt, an interest-rate
swap, a futures contract and a portfolio of all three have no common unit until
you express each as sensitivity to the same small move. Once you do, you can
add them up, and the sum is the position.

This is the practical reason DV01 wins over duration on a trading desk.
Duration is a percentage, so it needs a notional and a price before it means
anything. DV01 is already in money.

## The relationship to duration

They are the same idea in different clothing:

```
DV01 ≈ modified duration × price × 0.0001
```

A £10m position with modified duration 8 and a price of par has a DV01 of
roughly £8,000. Duration tells you the percentage sensitivity; DV01 tells you
the cash. Risk systems report the cash, because that is what a limit is
denominated in.

## Convexity, and the direction of the error

DV01 is a first derivative — a straight-line approximation to a curved
relationship. For a plain bond, the price/yield curve bends favourably:
**convexity** is positive, so prices rise more than DV01 predicts when yields
fall, and fall less than it predicts when they rise.

For a one-basis-point move that error is negligible, which is why the unit is
one basis point. For a fifty-basis-point move it is not, and a DV01-only view
understates your position in a rally and overstates the damage in a sell-off.

Not everything is positively convex. Mortgage-backed securities and callable
bonds can exhibit **negative convexity** — as yields fall, borrowers refinance
and the expected life shortens, so the position stops rallying. Here DV01 is
not merely imprecise; it points the wrong way about what happens next. Anything
with an embedded option needs the second-order term.

## One number is not enough

DV01 as usually quoted assumes a **parallel shift** — every point on the curve
moves by the same basis point. Curves do not oblige. They steepen, flatten and
twist, and a portfolio can be flat on parallel DV01 while carrying a large bet
on the shape.

Consider a book that is long two-year and short ten-year in DV01-neutral size.
Total DV01: zero. A parallel move does nothing. A steepening move can cost a
great deal.

The fix is **key-rate**, or partial, DV01: bucket the curve by tenor and shift
each bucket separately, holding the rest fixed. You get a vector rather than a
scalar — sensitivity at 2y, 5y, 10y, 30y — which is what a rates risk report
actually shows. The scalar is the sum, and the sum is the least informative
row.

## Hedging with it

DV01 is how hedge ratios are set. To hedge a position with an instrument, you
match the DV01s:

```
hedge notional = position DV01 ÷ hedge instrument DV01 per unit
```

If a corporate bond position has a DV01 of £42,000 and a futures contract has a
DV01 of £70 per contract, you need about 600 contracts. In practice this is
adjusted for the basis between the two instruments and rebalanced as DV01
itself drifts with yields — the hedge ratio is not constant, which is convexity
appearing again.

## Where it sits in a risk stack

DV01 is a **sensitivity**, not a loss estimate. It tells you how exposed you
are per unit of move; it does not tell you how large a move to expect. That is
the job of [VAR and Expected Shortfall](/learn/risk/var-and-es), which combine
sensitivities with a view on distribution.

Both matter, and they fail differently. Sensitivities are precise and local:
correct for small moves, silent about large ones. Distributional measures cover
the large moves and depend entirely on the history or model you feed them. A
desk watches both, and trusts neither alone.

## From the build side

My first serious risk work was extending Deutsche Bank's FX desk risk
calculator to Fixed Income — taking a system that priced one asset class and
teaching it another, then migrating the workflow off spreadsheets onto a live
platform. Later, at Revolut, DV01 was one line in a greenfield engine that also
carried mark-to-market, collateral and variation margin, VAR/ES and Greeks.

The recurring difficulty was never the derivative. It was **agreeing what a
position was**: the same trade represented differently in three systems,
settlement conventions that shifted a cash flow by a day, and day-count
conventions that quietly changed the answer. Anyone who has built one of these
will tell you the same thing — the risk number is a thin layer of arithmetic
over a deep pile of reference data, and the pile is where the bugs live.

---

## Dynamic hedging, and where the premium goes

Source: https://batiaev.com/learn/risk/dynamic-hedging
Topics: hedging, gamma, greeks, volatility, short premium, risk systems, pricing

Sell an option, hedge it to expiry, and watch the premium leave through the hedge — why the price you collect is the price of the gamma you are short.

Every other page here describes a position and what it is worth. This one is
about what happens next, because an option is not a bet you place and leave.
Sell one and you have taken on an exposure that changes every time the
underlying moves, and the only way to see what that costs is to run it forward.


## What the premium actually buys

Sell a thirty-day at-the-money call at 25% volatility and roughly 300 lands in
your account. It is tempting to read that as income. It is not. It is the
market's estimate of what it will cost you to stay flat until expiry.

Being short the call leaves you short delta as the underlying rises, so you buy
to stay hedged. When it falls you sell. Buy high, sell low, thirty times, and
the losses accumulate — that is what being short gamma means, and it is the
only reason anyone pays you the premium in the first place.

Run the figure above a few times. The premium is always about 300. The cost of
hedging is always about 300. What is left over changes sign from path to path
and is small either way. That is not the hedge failing. That is the option
being correctly priced.

## When you keep it

The premium is the price of a forecast: 25% annualised. The market either
delivers that or it does not.


The underlying barely leaves a six-point range, the hedge rarely has to chase
it, and the hedging bill comes to about 180 against the 300 you took in. You
keep the difference. This is the entire business model of a short-volatility
book, and it is also why those books look brilliant for long stretches and then
do not.


Same position, same discipline, same 300 collected. The underlying travels to
125 instead of 106, the hedge has to chase every swing, and the hedging bill
comes to nearly 380 — the premium gone, and about 75 of your own money with it.

The asymmetry worth noticing is not in these three numbers, which are close to
symmetric around the break-even. It is in the distribution behind them.
Realised volatility cannot fall below zero, so the best case is bounded: you
keep the premium and no more. There is no matching ceiling on the other side.
The quiet path pays you a known maximum; the violent path has no maximum at
all, and a thirty-day chart of a market that merely doubled its volatility is
nowhere near the bad end of that distribution.

## The part the model does not tell you

Black-Scholes assumes you rebalance continuously. Nobody does. Hedge thirty
times instead of infinitely often and you are left with an error that has
nothing to do with whether your volatility forecast was right — it is the
residual of a discrete approximation to a continuous instruction.

That error shrinks as you hedge more often, roughly with the square root of the
number of rebalances. Going from six hedges to sixty cuts the spread of
outcomes by about two thirds. It also multiplies your transaction costs, which
the model prices at zero and your broker does not.

So the real question on a hedging desk is never "how do I eliminate this error".
It is "where does the marginal hedge stop paying for itself" — and that is a
question about spread, commission and market impact, not about the Greeks.

## Why this page exists

The risk systems I have spent most of my career on exist to answer this
question across a book rather than a single position: what am I short, what
will it cost me to stay flat, and what happens to that number if the world
moves. SPAN answers a version of it for margin. VAR answers a version of it for
capital. This is the version a trader lives with every day.

The figures above use the same Black-Scholes implementation as the
[options P&L calculator](/tools/options-pnl) — no separate demo model, and no
market data. The paths are generated and seeded, so the same button always
produces the same story.

---

## Market data is a claim about the past

Source: https://batiaev.com/learn/markets/market-data
Topics: market data, latency, risk systems, measurement, pricing

Ticks, books and the plumbing between an exchange and a price on screen: normalisation, conflation, gaps, staleness, and what a composite price quietly hides.

A price on a screen looks like a fact about now. It is a claim about the past,
made by a venue, carried through several systems that each changed it a little,
and displayed some milliseconds — or seconds — after the event it describes.
Every system that prices, margins or executes against that number inherits
those changes, whether or not anyone wrote them down.

Market data is the least glamorous part of a trading platform and the one most
likely to be quietly wrong. Pricing models get reviewed. Feed handlers mostly
get noticed when they stop.

## What actually arrives

Venues publish at different depths, and the depth decides what you can know.

| Level | What it carries | What it lets you answer |
|---|---|---|
| L1 | Best bid, best offer, last trade | Where is the market? |
| L2 | Aggregated size at each price level | How much can I trade before the price moves? |
| L3 | Every individual order, add / modify / cancel | Who is queued ahead of me, and is that size real? |

Most retail-facing systems run on L1 and a few levels of L2. That is enough to
show a price, and not enough to know what a large order will cost — which is
why execution systems and display systems often subscribe to the same
instrument at different depths.

The other distinction that matters is **snapshot versus incremental**. A
snapshot is the whole book; an incremental feed is a stream of changes to it.
Incremental feeds are smaller and faster, and they carry a sequence number for
a reason: apply one update out of order, or miss one, and every book you build
afterwards is wrong in a way that looks perfectly plausible.

## Normalisation is where meaning changes

Each venue has its own symbology, tick sizes, lot sizes, price multipliers,
trading calendars and conventions for what a "trade" is. A feed handler
translates all of that into one internal model, and every translation is a
decision someone made once and nobody revisits:

- **Instrument identity.** The same economic thing can be several listings,
  and one ticker can mean different things on different venues. Mapping errors
  here do not crash anything; they price one instrument off another.
- **Price scaling.** Pence versus pounds, quoted versus clean price, a futures
  multiplier applied twice or not at all. A factor of 100 is easy to spot. A
  factor of 1.0125 is not.
- **Trade conditions.** Auction prints, off-book trades, late reports and
  corrections all arrive as "trades". A last-price field that includes them is
  measuring something different from one that does not.
- **Calendars.** Half-days, holidays and session breaks decide whether a quiet
  feed is a closed market or a broken connection.

The useful habit is to keep the raw message alongside the normalised one for
long enough to answer "what did the venue actually say?" When a client disputes
a fill, that question arrives within the hour.

## Gaps, recovery and the book you cannot trust

Sequence numbers make gaps detectable; they do not make them harmless. When a
gap appears the honest state of the book is *unknown*, and the system has to
choose:

1. **Stop and recover.** Mark the instrument stale, request a snapshot or
   replay, rebuild, then resume. Correct, and briefly blind.
2. **Carry on.** Keep applying updates to a book known to be missing some.
   Fast, and wrong in a way that cannot be measured.

Anything that prices or margins should take the first option and say so. The
second is how a crossed book — best bid above best offer — ends up feeding a
risk engine, which then reports a profit that does not exist.

Crossed and locked markets are worth checking for explicitly. They are rare on
a single healthy venue, common across venues for a few milliseconds, and almost
always a sign of a stale side when they persist.

## Conflation and staleness

A busy instrument can update tens of thousands of times a second, and most
consumers cannot use that. **Conflation** keeps the latest state and drops the
intermediate ones: a screen redrawing at 4Hz needs the price as of now, not
every price since the last frame.

Conflation is right for display and dangerous for anything that needs the
path — a stop that should have triggered at a price the conflated stream never
showed, or a volume-weighted calculation computed over a sample instead of the
trades.

Staleness is the mirror problem: a price that has not changed may be a quiet
market or a dead connection. The two look identical in the data. Good systems
carry the time of the last update next to every price, and the age of that
timestamp — not the price — is what a dealer looks at first when something
seems off. A coloured "seconds since last update" next to a figure is one of
the most useful pieces of UI in a dealing tool, because it answers the question
before it is asked.

## Timestamps, plural

A single tick can carry several times:

- when the venue matched or published it;
- when it reached your network;
- when your handler decoded it;
- when your application acted on it.

The gaps between them are your latency budget, measured. Keeping only the last
one — usually the local receive time — throws away the ability to say whether
a slow fill was the venue, the network or your own code. Clocks also need to
agree: a timestamp from a server that has drifted by a few milliseconds will
make causality appear to run backwards in your logs.

## What a composite price hides

Platforms that quote one price per instrument usually build it from several
sources: venues, liquidity providers, a reference feed. The composite is a
policy, not a measurement. It has to decide which sources count, how to weight
them, how to treat one that has gone quiet, and what to do when they disagree.

That policy is invisible in the output. A smooth composite can hide one source
that has been stale for a minute and another that has started printing outliers.
The defence is to keep each source's contribution inspectable — which source
set the bid, how old it was, how far the others were from it — so that when the
composite moves, someone can say why.

## The short version

- Treat every price as *price, source, time* — never price alone.
- Prefer a stale flag to a confident wrong number.
- Recover from gaps; do not paper over them.
- Conflate for people, not for risk.
- Keep the raw message long enough to answer a dispute.

None of this is visible when it works, which is exactly why it needs owning.
The [execution note](/learn/markets/execution) picks up where the price ends
and an order begins, and the [market making note](/learn/markets/market-making)
covers what a dealer does with the price once it is trusted.

---

## Market making is inventory management

Source: https://batiaev.com/learn/markets/market-making
Topics: market making, hedging, pricing, inventory, volatility, risk systems

Where a spread comes from, why a market maker skews rather than widens, the reservation price, adverse selection measured by markouts, and when to hedge rather than hold.

A market maker quotes a price to buy and a price to sell, and earns the gap
between them. Described like that it sounds like a toll booth. In practice the
spread is the smaller part of the job. The larger part is the inventory that
every fill leaves behind, and the uncomfortable fact that the clients most
eager to trade with you are often the ones who know something you do not.

## Where a spread comes from

The classic decomposition has three parts, and each points at a different
lever:

| Component | What it pays for | What moves it |
|---|---|---|
| Order processing | Fees, infrastructure, people | Scale and automation |
| Inventory | Carrying a position you did not choose | Volatility, position size, time to unwind |
| Adverse selection | Trading against better-informed flow | Who the counterparty is, and how fast prices move after the fill |

Ho and Stoll formalised the inventory part in 1981; Glosten and Milgrom the
adverse-selection part in 1985. Neither is new. What changes in a real system
is that all three are measured continuously, per instrument and per client
segment, rather than assumed.

## Skew before you widen

When a market maker accumulates a long position the instinct is to widen both
sides. That is usually the wrong move. Widening makes you less competitive on
the side that would *reduce* your risk as well as on the side that would add
to it.

The better move is to **skew**: shift both quotes down, so your offer becomes
more attractive — someone buys your inventory from you — and your bid less
attractive, so fewer people sell you more. The spread can stay the same width
while its centre moves away from the market mid.

Avellaneda and Stoikov (2008) made this precise. Their **reservation price** —
the price at which the market maker is indifferent to holding one more unit —
is the mid adjusted for inventory:

```
r = s − q · γ · σ² · (T − t)
```

where `s` is the mid, `q` the signed inventory, `γ` risk aversion, `σ` the
volatility and `T − t` the time left to carry the position. Quotes are then
placed around `r`, not around `s`.

A worked illustration, with round numbers rather than market ones: mid 100.00,
long 10 units, `γ = 0.01`, `σ = 2` per square-root day, half a day left.
The adjustment is `10 × 0.01 × 4 × 0.5 = 0.20`, so the reservation price is
99.80 and both quotes slide twenty cents down. Double the position and the skew
doubles. Double the volatility and it quadruples — which is the formula's way
of saying that inventory in a fast market is much more expensive than the same
inventory in a slow one.

The same paper gives the optimal total spread:

```
δ = γ · σ² · (T − t) + (2 / γ) · ln(1 + γ / k)
```

where `k` measures how quickly the chance of a fill falls away with distance
from the mid. The spread widens with volatility and with the time left to carry
the position, and narrows as `k` rises — when competition for flow is fierce,
quoting wide simply stops getting filled. Risk aversion is less obvious than it
looks: it raises the first term and lowers the second, so a more cautious market
maker skews harder but does not necessarily quote wider.

## Adverse selection, measured

You cannot see a counterparty's information. You can see what the market did
after you traded with them. That is a **markout**: the move in the mid, from
your side of the trade, at a set horizon after the fill.

- Buy at 99.98, mid is 99.90 a second later: −8 ticks at one second.
- The same at ten seconds and sixty seconds gives a curve.

Average those curves by client segment, venue or order type, and the toxic flow
identifies itself. Benign flow has markouts that hover around zero. Informed
flow has markouts that fall steadily against you, and the horizon at which they
stop falling tells you how fast the information was.

Markouts are the single most useful number a dealing desk computes, because they
turn an argument ("this client is too smart for us") into a measurement, and
because they separate two problems that look the same in P&L: quoting too
tight, and quoting the wrong people.

## Hold, net or hedge

Every fill leaves exposure, and there are three things to do with it:

1. **Hold it** and let the skew work it off. Cheapest, if the market cooperates.
2. **Net it** against opposing client flow. A dealer facing many clients often
   finds that buyers and sellers offset each other for much of the day, and only
   the residual needs managing.
3. **Hedge it** externally — in the underlying, a future, or a correlated
   instrument. This costs a spread and carries basis risk, but caps the loss.

The decision is a limit structure, not a judgement call made trade by trade:
position limits per instrument and per correlated group, a loss limit, and
rules for when the residual is hedged automatically. A hedging algorithm then
decides *how* — slicing the hedge, choosing venues and managing its own market
impact — which is the problem the [execution note](/learn/markets/execution)
covers.

## Options make it two-dimensional

An options market maker carries the same problem with more axes. The inventory
is not a quantity but a set of Greeks: delta, which is hedged continuously in
the underlying, and gamma and vega, which can only be reduced by trading other
options. Skew then applies to the **volatility surface** rather than to a
price: a book that is long vega lowers the implied volatility it quotes,
across the strikes and expiries where it is long.

The cost of carrying that gamma is exactly what the
[dynamic hedging note](/learn/risk/dynamic-hedging) simulates: the premium
collected for an option is the price of the hedging it is about to require.

## What breaks in practice

- **Stale inputs.** Quoting off a price that has stopped updating is the fastest
  way to be picked off. Every quoting engine needs a staleness kill switch —
  see the [market data note](/learn/markets/market-data).
- **Correlated inventory.** Ten small positions in instruments that move
  together are one large position. Limits set per instrument miss it.
- **Feedback loops.** Your own hedging moves the market your quotes are built
  on. A hedge that is too aggressive shows up as worse markouts on your own
  next fills.
- **Regime change.** Parameters fitted on a quiet month are wrong on the day it
  stops being quiet, which is the day they matter.

None of this needs exotic maths. It needs every number — spread, skew, markout,
residual — to be visible to the people accountable for the book, live, with the
age of the data beside it.

---

## Execution, from order to fill

Source: https://batiaev.com/learn/markets/execution
Topics: execution, latency, market data, hedging, risk systems, measurement

Order types, smart order routing and liquidity aggregation, the latency budget, pre-trade risk checks, and how to measure what execution actually cost.

"Buy 1,000" is an instruction. What the client receives is a set of fills at
prices, times and venues, and the difference between the two is execution.
Most of the work happens in the few milliseconds nobody sees, and the quality of
it only becomes visible in aggregate — which is why it is measured badly so
often.

## Order types are risk choices

Every order type trades certainty of execution against certainty of price.

| Order | Guarantees | Risks |
|---|---|---|
| Market | It fills (if there is liquidity) | The price, in a thin or fast market |
| Limit | The worst price | That it never fills |
| Stop | That it triggers at a level | The fill price after triggering — a stop becomes a market order |
| Stop-limit | Trigger and worst price | Triggering, then not filling, while the market runs away |
| IOC / FOK | No resting order left behind | Partial or no fill |

The useful framing for clients and for product teams alike: a market order buys
certainty that you trade and pays for it in price; a limit order buys certainty
of price and pays for it in the risk of missing the trade. A stop is not
protection against gaps — when the market opens through it, the fill is wherever
the market is.

## Smart order routing

When the same instrument trades in several places, an order has to decide
where to go. A **smart order router** takes the parent order and the current
state of each venue and produces child orders:

1. Build the consolidated book from each venue's depth.
2. Adjust each venue's prices for its fees, rebates and expected fill
   probability — the headline price is not the price you get.
3. Walk the book, taking the best effective prices until the order is filled
   or the limit is reached.
4. Send the child orders, ideally so that they arrive together, because the
   first fill is a signal to anyone watching the other venues.
5. Handle what comes back: partial fills, rejects, and quotes that had moved by
   the time the order arrived.

Step 4 is where latency stops being an engineering metric and becomes a cost.
Orders that arrive at different venues a few milliseconds apart give
faster participants time to adjust the quotes the router was relying on.

## Liquidity aggregation

A broker or dealer that hedges through several liquidity providers runs the
same logic in a different setting. Each provider streams quotes, often with
different sizes, different validity, and different rules about whether a
request at that price will actually be honoured. **Last look** — a provider's
right to reject a trade request within a short window after seeing it — means a
quote is an offer to consider, not a commitment.

The aggregator therefore keeps statistics, not just prices: per provider, the
fill ratio, the reject ratio by market condition, how long the last look takes,
and the markouts after the fill. A provider with the best headline price and a
high reject rate in fast markets is often the most expensive one in the book.

At Revolut the liquidity aggregation, smart order routing and hedging algorithms
ran with a roundtrip under 60 milliseconds. The number matters less than the
discipline behind it: knowing where each millisecond went.

## The latency budget

End-to-end latency is a sum, and each term has an owner:

- market data in: venue → network → feed handler → book;
- decision: risk checks, pricing, routing logic;
- order out: gateway → network → venue;
- acknowledgement and fill back, through the same path.

Measuring only the total tells you there is a problem and nothing about where.
Timestamping at each boundary — and keeping the clocks that write those
timestamps in agreement — turns "the platform is slow" into "the risk check
added 4 milliseconds after the last release", which is a problem someone can
fix.

Tail latency matters more than the average. A system that answers in 2
milliseconds at the median and 400 at the 99.9th percentile will hurt clients
precisely on the busy days, because the tail is where the volume is.

## Pre-trade risk checks

Every order passes through checks before it leaves: does the client have the
margin, is the size inside limits, is the price within a band of the market, is
this order a duplicate, is the instrument tradable right now. They are the
cheapest insurance a platform buys, and they sit directly in the latency path,
so two properties matter:

- **They must be fast and deterministic** — no network calls on the hot path
  that can stall.
- **They must fail closed.** If a check cannot decide, the order does not go.
  A risk check that times out and lets the order through is not a risk check.

Fat-finger price bands deserve particular care: too tight and they reject
legitimate orders on volatile days, too loose and they let through the error
they exist to stop.

## Measuring what it cost

Execution quality is measured against a benchmark, and the choice of benchmark
decides the answer.

- **Arrival price.** The mid when the order was decided. The gap to the average
  fill price is **implementation shortfall**: everything execution cost,
  including the market moving while you worked the order.
- **Spread capture.** Where inside the bid-offer the fill landed.
- **VWAP.** Fill price against the volume-weighted average over the period.
  Useful for large orders worked over time; flattering for small ones, which
  are part of the volume they are measured against.
- **Markouts.** The same post-trade measure a market maker uses, from the
  client's side: did the price keep moving after the fill?

Regulation in Europe frames all of this as best execution: firms must take all
sufficient steps to obtain the best possible result for clients, considering
price, costs, speed, likelihood of execution and settlement, size and nature.
The practical consequence is that every one of the numbers above has to be
computable after the fact, per order, with the market data that was true at the
time — which takes us back to [market data](/learn/markets/market-data).

## The short version

- Pick order types for the risk you would rather carry.
- Route on effective prices, not headline ones.
- Score liquidity providers on fills and markouts, not quotes.
- Budget latency per hop, and watch the tail.
- Keep pre-trade checks fast, deterministic and closed on failure.
- Measure against arrival price before anything that flatters you.

---

## The harness is most of the product

Source: https://batiaev.com/learn/ai/harness
Topics: agents, harness, verification, ai, product engineering

A model is one component. The context it is given, the tools it may call, the permissions around them and the checks after them decide whether an agent is useful.

When an agent does something useful, the model gets the credit. When it does
something stupid, the model gets the blame. Both are mostly misattributed. The
same model is excellent or useless depending on what it is shown, what it is
allowed to do, and what happens to its output before anyone relies on it — and
all three of those belong to the **harness**, not the model.

A harness is everything wrapped around the model call: context assembly, tools,
permissions, hooks, memory and verification. It is ordinary software, it is
where most of the engineering effort goes, and it is where a team's taste and
standards actually live.

## The parts

| Part | Question it answers | Fails as |
|---|---|---|
| Context | What does the model know right now? | Confident answers about the wrong version of the code |
| Tools | What can it do? | Workarounds through whatever tool is available |
| Permissions | What may it do without asking? | Either constant interruptions or an incident |
| Hooks | What always happens around an action? | Rules that are only followed when remembered |
| Memory | What carries over between sessions? | The same correction made every week |
| Verification | How do we know it worked? | "Done" meaning "I wrote some code" |

## Context is a budget, not a dump

The cheapest way to improve an agent is to give it less, better context. A
model reading forty files to find the three that matter is slower, more
expensive and more likely to latch onto the wrong pattern than one that is
handed the three.

What works in practice is **layered, scoped context**:

- A short brief at the root of each repository — what the system is for, the
  hard rules, the commands that prove something works. On this site that is a
  single `AGENTS.md`, with `CLAUDE.md` pointing at it so the two cannot drift.
- Rules that attach by path. In the workspace I build SHIP in — eight
  repositories: app, backend, CLI, browser extension, MCP server, website,
  policies and infrastructure — each repository's conventions live in a rule
  file that only loads when the agent touches files matching its glob. The
  backend rules never cost tokens during a front-end change.
- Skills for repeatable procedures — "create a database migration", "regenerate
  the API client", "prepare a release" — written once, loaded on demand.

The test for anything in the brief is whether it is recoverable from the code.
Directory structure is; *why* a choice that looks wrong is deliberate is not.
Briefs that describe the code go stale; briefs that record judgement stay
useful.

## Tools shape behaviour

An agent uses the tools it has. Give it only a shell and it will edit files with
`sed`, query databases by piping SQL strings and parse JSON with `grep`. Each
works until it does not. Dedicated tools — edit a file by exact replacement,
query with a typed interface, read a page as text — make the right action the
easy one, and they make actions auditable because their arguments are
structured.

The same applies to the interfaces an agent reaches outside the machine. A
typed MCP server with a narrow set of tools is a contract: what the agent can
read, what it can write, and in what shape. That is a much smaller surface to
reason about than "it has an API key".

## Permissions follow reversibility

Permission design gets easier once actions are sorted by how hard they are to
undo:

1. **Read anything in scope** — no prompt.
2. **Edit the working tree** — no prompt, because version control is the undo.
3. **Run commands that change local state** — allow-listed by pattern.
4. **Anything outward-facing or irreversible** — pushing, deploying, sending a
   message, deleting data, spending money — a human confirms, every time.

The failure mode at one end is an agent that asks before every file read and
gets switched to "allow everything" by Friday. At the other end it is an agent
that force-pushes over a colleague's branch. Sorting by reversibility gives a
policy people keep.

## Hooks make rules unforgettable

A rule in a prompt is followed when the model remembers it. A hook is followed
every time. Anything that must always happen belongs in a hook:

- A pre-tool hook in the SHIP workspace scans every write for secret-like
  patterns and warns before the content lands on disk.
- An editor hook reminds that a change to the database schema file needs a
  migration revision — the mistake that is cheapest to catch at edit time and
  most expensive in production.
- Formatting and linting after edits, so the diff a reviewer sees is the
  substance and not the whitespace.

The pattern is the same as in any engineering system: move a check from
"someone should remember" to "the system does it".

## Verification is the product

The hardest part of agentic work is not producing a change. It is knowing
whether the change is right. A harness earns its keep by making verification
cheap and non-negotiable:

- a single command that runs the gate — on this site `npm run verify`, which
  runs eight numeric suites and a render smoke test, around 330 checks;
- tests that assert properties rather than snapshots, so the agent cannot pass
  them by regenerating the expected output;
- a real environment to look at — a dev server, a browser, a simulator — so
  "it compiles" is not mistaken for "it works".

An agent that can run the gate itself iterates until it passes. An agent that
cannot will report success on the first attempt that looks plausible. The
[agentic workflows note](/learn/ai/agentic-workflows) is about building that
loop deliberately.

## Why this is the product

Two teams on the same model will get very different results, and the
difference is almost entirely harness: what they wrote down, what they
automated, what they refuse to let through. That is good news. Models change
every few months; a well-built harness carries over, and it compounds — every
correction written into a rule, a skill or a hook is one the team never makes
again.

---

## Agentic workflows that hold up

Source: https://batiaev.com/learn/ai/agentic-workflows
Topics: agents, verification, evals, ai, product engineering

Plan, act, verify — and why the verify step has to be something the model cannot talk its way past: tests, type-checks, property checks, and a human at the irreversible step.

Every agentic workflow is a loop: decide what to do, do it, check whether it
worked, repeat. The first two steps get the demos. The third decides whether
the result can be trusted, and it is the one most often left to the model's own
judgement — which is to say, skipped.

The rule that makes these loops hold up is simple to state: **the check has to
be something the model cannot talk its way past.**

## Plan, act, verify

**Plan** is where scope gets decided, and where most expensive mistakes are made
cheaply. A plan written down before any change — which files, which approach,
how success will be shown — gives a human one place to say "no, not like that"
before an hour of work goes in the wrong direction. It also gives the agent
something to check itself against later.

**Act** should be small. A diff a reviewer can read in two minutes gets read; a
diff that touches forty files gets approved. Small steps also make failure
cheap: when step four breaks something, steps one to three are still good.

**Verify** is a gate, not an opinion. Compare:

| Weak check | Strong check |
|---|---|
| "The code looks correct" | The tests pass |
| The tests the agent just wrote pass | Tests that existed before the change still pass |
| Snapshot tests regenerated | Property tests: monotonicity, round-trips, known answers |
| "It builds" | The page renders and the number on it is right |
| The agent says it is done | A command exits zero |

The strong column has one thing in common: the agent does not control the
outcome. That is the point.

## Property checks beat examples

For anything that computes, the most robust gate is a set of properties rather
than a list of expected outputs. This site's calculators are checked that way:

- **Closed-form anchors.** Hedging an option at zero volatility must compound to
  exactly `exp(rt)`.
- **Round-trips.** Price at a volatility, invert the price, recover the
  volatility to 1e-7.
- **Monotonicity.** Every lever must pull the right way — more contribution,
  more money.
- **Statistical tolerance.** A Monte Carlo result is compared against its own
  standard error, not a magic number.
- **Hostile input.** An empty field, a crossed market, a quote below intrinsic.

An agent can make an example test pass by changing the example. It cannot make
"inverting the price recovers the volatility" pass without the maths being
right. That asymmetry is what lets a loop run unattended for longer.

## Humans at the irreversible step

Autonomy should scale with reversibility, not with confidence. An agent can
iterate on a working tree all afternoon because version control undoes
anything. It should not push, deploy, send, delete or pay without a person
saying yes — and that approval should be specific to the action, not a blanket
"go ahead" that silently covers the next one.

On this site the split is explicit: the agent can change anything in the source
and run every check, but nothing is live until the static build is regenerated
and committed, and that step is mine.

## Sub-agents for separation, not speed

Splitting work across agents is tempting for throughput. Its better use is
**separation of concerns**:

- a reviewer agent that sees only the diff and the brief, not the reasoning
  that produced it, so it is not persuaded by the author's story;
- a researcher that reads widely and returns a conclusion, so the main context
  is not filled with forty files it will never need again;
- specialists with narrow briefs — security, database migrations, compliance
  language — whose instructions would be noise in every other task.

Each spawn starts cold and re-derives context, so it is not free. Use it where
independence is the value.

## Evals: the regression suite for behaviour

Code has tests; agent behaviour needs **evals** — a fixed set of tasks with a
way of scoring the result, run whenever the prompt, the tools or the model
change. Without them every change to the harness is a guess, and model upgrades
become anxious events instead of routine ones.

Good evals look like the work: real tasks from the backlog, real failure cases
that were fixed once, graded on whether the outcome was correct rather than
whether the transcript looked confident. A handful of honest evals beats a
leaderboard of synthetic ones.

## Cost and latency are design inputs

Every loop iteration costs tokens and time. That shapes design:

- give the agent the cheapest check first — the type-checker before the full
  test suite, the unit test before the browser;
- keep stable context stable, so it can be cached rather than re-sent;
- stop loops that are not converging. Three failed attempts at the same fix
  usually mean the plan is wrong, not the code.

## What changes for the team

The bottleneck moves. Writing the change gets cheap; specifying it and checking
it do not. Teams that do well with agents write better briefs, invest in
faster and stricter gates, and treat every recurring correction as a bug in the
harness rather than in the model. The
[harness note](/learn/ai/harness) covers where those corrections live, and the
[product engineering note](/learn/ai/product-engineering) what it does to how a
team is organised.

---

## Knowledge bases: typed beats retrieved

Source: https://batiaev.com/learn/ai/knowledge-bases
Topics: agents, knowledge, retrieval, mcp, provenance, ai

Why retrieval over a pile of documents fails quietly, what hybrid search fixes, and why goals, decisions and artefacts work better as typed nodes with provenance.

The usual way to give a model knowledge is to put the documents in a vector
store and retrieve the closest chunks at question time. It demos well, and it
fails quietly — not with an error, but with a fluent answer built from the wrong
paragraph of the wrong version of the right document.

That failure is structural, and fixing it is less about better retrieval than
about deciding what the knowledge actually is.

## How retrieval goes wrong

A retrieval pipeline has four stages, and each loses something:

| Stage | What it does | What it loses |
|---|---|---|
| Chunk | Split documents into passages | The sentence before, which said "this was rejected" |
| Embed | Turn passages into vectors | Exact terms — ticker symbols, error codes, names |
| Retrieve | Return the nearest passages | Anything phrased differently from the question |
| Generate | Answer from what came back | The fact that what came back was incomplete |

The last row is the dangerous one. The model cannot know what retrieval did not
return, so it answers from what it has, confidently. A decision that was made in
March and reversed in May is two documents; whichever chunk is closer to the
question wins.

## Hybrid search fixes recall

Semantic search is good at meaning and bad at precise terms. Full-text search is
the opposite. Running both and merging the results — then re-ranking the merged
list — fixes most recall problems at modest cost. The AI retrieval stack I
built at Nevis combined full-text and semantic search for exactly that reason:
in wealth management the questions name specific funds, forms and account
types, and an embedding alone will happily return a passage about a similar
one.

Hybrid search makes retrieval better. It does not make it *right*, because the
underlying problem is not finding passages. It is that passages are the wrong
unit for most of what an organisation needs to know.

## Typed knowledge

Ask what an engineering team actually needs an agent to know, and the answer is
rarely "the paragraph that mentions X". It is:

- what the team is trying to achieve — **goals**;
- what was decided, by whom, and why — **decisions**;
- what exists — **artefacts**: services, repositories, documents, pull requests;
- how those relate — this decision serves that goal, this artefact implements
  that decision.

Represented as typed nodes with typed edges, those questions stop being
retrieval problems. "What is the current decision on the auth provider?" is a
lookup of a node of type *decision*, scoped to *auth*, that has not been
superseded — not a similarity search over every message that mentions auth.

This is the design behind SHIP: goals, decisions and artefacts as typed nodes
instead of prose, which agents read and write through MCP.

## Provenance and supersession

Two properties make a knowledge base trustworthy enough for agents to act on.

**Provenance.** Every node records who wrote it — which person or which agent —
from which source, and when. An answer can then say where it came from, and a
reviewer can discount a claim that came from an agent's inference rather than a
human decision. In SHIP an agent's write is recorded as an agent observation and
audit-logged; it does not silently become fact.

**Supersession.** Knowledge changes. A decision that is replaced should not be
deleted — the history of why it changed is often the most useful part — but it
must be marked as superseded, with a link to what replaced it. Retrieval over
documents has no equivalent: the old version and the new one are just two
passages.

## MCP is the boundary

The Model Context Protocol gives agents a typed interface to a system: a list of
tools, each with a schema. For a knowledge base that is the right boundary,
because it makes the contract explicit:

- **Reads** are broad: search, fetch a node, traverse its relations.
- **Writes** are narrow and attributable: record an observation, propose a
  status change, link two nodes — never "rewrite the graph".
- **Some writes are not offered at all.** Where an agent writing a wrong value
  is worse than no agent, the tool is read-only and the record is still entered
  by a person. The capability you leave out is part of the design.

The same interface serves every assistant the user already has. One knowledge
base, reachable from whichever client a person prefers, beats a separate
memory locked inside each.

## When retrieval is still right

Typed structure is not free: someone, or something, has to create the nodes.
For large bodies of reference text — manuals, regulations, research — retrieval
remains the right tool, ideally hybrid and with citations back to the source
passage. The practical architecture is both: a typed core for the things the
organisation decides and owns, and retrieval around it for the things it reads.

## The short version

- Retrieval finds passages; organisations run on decisions.
- Hybrid search for recall, re-ranking for precision, citations for trust.
- Type the knowledge that changes and matters: goals, decisions, artefacts.
- Record provenance on every write and supersede rather than delete.
- Make the agent interface narrow where mistakes are expensive.

The [harness note](/learn/ai/harness) covers how this knowledge reaches a model
as context, and the [agentic workflows note](/learn/ai/agentic-workflows) how to
check what the model does with it.

---

## Product engineering when code is cheap

Source: https://batiaev.com/learn/ai/product-engineering
Topics: product engineering, verification, agents, ai, knowledge

When an agent can write the diff, the scarce work moves to the spec, the verification and the taste encoded in rules — and the line between product and engineering moves with it.

For most of the history of software, the expensive part was writing the code.
Planning, process and team shape all grew around that constraint. Agents have
not removed it, but they have moved it: a competent first draft of a change is
now minutes away. What is still slow is knowing which change to make, and
knowing whether the one you got is right.

That shift changes what good product engineering looks like, and it changes it
for product managers and engineering leaders as much as for engineers.

## The new bottlenecks

| Used to be scarce | Now scarce |
|---|---|
| Typing the code | Saying precisely what should change |
| Knowing the syntax | Knowing which details decide whether it holds up |
| Review of a colleague's diff | Review of a machine's diff, at volume |
| Writing tests | Writing checks the author cannot game |
| Documentation nobody reads | Briefs an agent reads on every task |

Every row on the right is a judgement problem. None of them gets easier because
the model got better at code.

## The spec is the artefact

When an agent implements, the spec stops being a ticket someone skims and
becomes the input that determines the output. A good one is short and
specific:

- **What and why** — the user problem, in one paragraph.
- **The shape of done** — what someone will see, and the check that proves it.
- **Constraints** — what must not change, what must not be invented, which
  existing pattern to follow.
- **Open questions** — named, so they get answered rather than guessed.

Writing that well is product work. It is also the cheapest point in the whole
process to catch a wrong idea — the plan costs a minute to read; the
implementation of the wrong plan costs a review cycle and a revert.

## Taste becomes configuration

Every team has standards that live in people's heads: how dense a table should
be, which error messages are acceptable, why a figure is never shown without
its source, when a number must say it was simulated. Agents do not absorb those
by osmosis. They follow what is written down.

So taste moves into files: a design system with named components and tokens, a
brief per repository, rules that attach to the paths they govern, checks that
fail the build when a raw colour sneaks past the tokens. This site is an
example — its brief carries rules like *never fabricate market data* and
*motion must compute something*, and every change, by a person or an agent,
starts from them.

The side effect is welcome: standards that are written down can be argued with,
versioned and improved. Standards in people's heads mostly get re-litigated.

## Verification scales the team

If an agent can produce ten changes a day, the team needs to be able to trust
ten changes a day. That is a verification problem, and it is solved the same
way it always was, only with less tolerance for gaps:

- fast, strict gates that run on every change;
- property and invariant tests for anything that computes;
- a real environment to look at, not just a green build;
- humans reviewing intent and risk, not formatting.

The [agentic workflows note](/learn/ai/agentic-workflows) goes into the gates.
The organisational point is that investment in verification used to be a
quality decision. It is now a capacity decision.

## The product–engineering line moves

When implementation is cheap, the person closest to the problem can often get
much further on their own. Product managers prototype the change instead of
describing it. Engineers spend more time on what to build and how to prove it,
and less on transcription. Designers ship the component rather than the
picture of it.

That does not remove the roles. It removes the hand-offs between them that
existed only because writing code was slow. What remains distinct is
accountability: who decides what good is, and who answers for it when it is
not.

## Knowledge is infrastructure

An agent is only as good as what it knows about the product, the codebase and
the decisions behind both. A team that keeps its goals, decisions and artefacts
somewhere structured — not scattered across chat threads and stale wiki pages —
gives every agent and every new hire the same head start. That is the problem
SHIP exists for, and the [knowledge bases note](/learn/ai/knowledge-bases)
explains why typed structure beats retrieval for it.

## What to do on Monday

1. Write a one-page brief for your main repository: purpose, hard rules, the
   command that proves a change works.
2. Make that command fast enough that people — and agents — actually run it.
3. Turn your three most frequent review comments into rules or checks.
4. Require a written plan before any change larger than a single file.
5. Keep irreversible steps — deploys, data changes, messages to customers —
   behind a human, explicitly.

None of it needs a new tool. All of it gets more valuable the more of the work
is done by agents.

---

## Books

Source: https://batiaev.com/learn/library/books
Topics: books, further reading, culture, volatility, greeks, risk measure, pricing

The reference texts worth owning, the narratives worth reading, and where to look when both run out.

A short list rather than a long one. Everything here I have actually read, and
I have said why in my own words — go to the publishers for the real thing.

## The reference

**Options, Futures and Other Derivatives** — John C. Hull. The standard text,
and standard for a reason: it is the book desks actually keep on the shelf. Not
a book to read cover to cover. A book to own and open at the chapter you need,
which for most people is binomial trees first and the Greeks second.

**Option Volatility and Pricing** — Sheldon Natenberg. Where Hull gives you the
mathematics, Natenberg gives you the trader's intuition for what the numbers
mean when the market is moving. If you only read one, and you intend to trade
rather than to price, read this one.

**Dynamic Hedging** — Nassim Nicholas Taleb. Difficult, opinionated, and
written by someone who ran the risk rather than modelled it. Worth the effort
specifically for its treatment of the places where the standard model quietly
stops working.

## Narrative and memoir

The textbooks tell you how the instruments work. These tell you what happens
when people use them.

**Liar's Poker** — Michael Lewis. Salomon Brothers in the eighties, and more or
less the book that invented this genre. Everything below is in conversation
with it.

**The Big Short** — Michael Lewis. Sharper than the film on the actual
mechanics of the trade: what the CDS contracts said, why the counterparties
kept writing them, and how long being right can take.

**Flash Boys** — Michael Lewis. HFT and market microstructure. Contested by
practitioners on several points, and still the most readable route into why
venue design, latency and order routing decide who gets filled.

**When Genius Failed** — Roger Lowenstein. The definitive account of LTCM: a
quant fund with the right models blowing up on a liquidity constraint and a
correlated market. The relevant lesson is not that the mathematics was wrong.

**Fool's Gold** — Gillian Tett. The JPMorgan team that invented the credit
derivatives later used to blow up the system. Narrative rather than textbook,
and unusually good on how a well-intentioned instrument gets away from its
authors.

## On risk, more broadly

**Against the Gods** — Peter L. Bernstein. A history of how humanity learned to
measure risk at all. Useful perspective on why the tools look the way they do.

**The Black Swan** — Nassim Nicholas Taleb. Overexposed and still worth it, if
you read it as an argument about the shape of distributions rather than as
general-purpose contrarianism.

## Engineering, for the systems underneath

**Designing Data-Intensive Applications** — Martin Kleppmann. Nothing to do
with options, everything to do with building the systems that price them. The
chapters on consistency and stream processing are the ones that mattered to me
when we were building risk engines that had to be correct at a million updates
a second.

## Where else to look

The exchange documentation is better than most books for mechanics —
specifications, margin methodology, contract terms. It is dry, free, and
authoritative, which is a rare combination. If you want to understand SPAN
margining, the exchange's own methodology paper will teach you more in an hour
than any textbook chapter.

---

## TV series

Source: https://batiaev.com/learn/library/series
Topics: series, further reading, culture, risk measure

Longer form gets closer to the texture of the job than any film has managed — desk culture, hierarchy, and the parts nobody puts in a prospectus.

A film has two hours and needs a crisis to fill them. A series has time for the
ordinary weeks — the standups, the politics, the slow attrition — which is
where almost all of the actual job lives.

## On the desk

**Industry** (2020– ). The most accurate thing on screen about grad-scheme
culture, desk politics and the psychological cost of sell-side trading. It gets
the jargon and the hierarchy right, which almost nothing else does, and it is
honest that most of the pressure is social rather than mathematical.

## On the buy side

**Billions** (2016–2023). Hedge fund against US Attorney, at length. More about
power and ego than mechanics, but genuinely good on activist positions, the
politics of a fund's investor base, and the grey edges of insider trading.

## Adjacent, and worth it

**Succession** (2018–2023). Not finance exactly, and still essential on
family-controlled conglomerates, M&A, and how a board actually gets worked. If
you have ever sat in a governance meeting where the real decision happened
somewhere else, it will feel familiar.

Watch all three for the culture rather than the mechanics. None of them will
teach you to price anything, and that is not what they are for.

---

## Films

Source: https://batiaev.com/learn/library/films
Topics: films, further reading, culture, pricing

Which films get the culture right even when they bend the mechanics, and which ones to watch knowing exactly what they are.

Watch these for the culture, not the mechanics — all of them compress and
simplify, and some of them are fiction throughout. Ranked roughly by how much
of the job they get right.

## The ones that get it right

**Margin Call** (2011). The best of them: a risk model returns an unacceptable
number overnight, and the rest is people deciding what to do about it.
Understated, dialogue-driven, and accurate about hierarchy in a way the others
are not. If you watch one, watch this.

**The Big Short** (2015). The clearest popular explanation of CDOs and credit
default swaps ever put on screen, at the cost of some caricature. Conceptually
sound, and the fourth-wall explainers earn their place. Read the book for the
mechanics.

**Trading Places** (1983). A comedy that ends in a commodities pit, and
genuinely useful on how a corner works. Also responsible, indirectly, for a
rule in US law about trading on misappropriated government data.

## The ones about the culture

**Wall Street** (1987) and **Money Never Sleeps** (2010). Dated, and still the
cultural template for the whole era — "greed is good" came from here, and was
not meant as advice. Watch the first; the sequel is for completeness.

**Boiler Room** (2000). Pump-and-dump brokerage culture. More about sales cults
than about trading, which is precisely what makes it useful: the pressure it
depicts is real and has not gone anywhere.

**The Wolf of Wall Street** (2013). Stratton Oakmont at full volume. About
excess and fraud rather than markets. Enjoyable, frequently mistaken for
aspirational, and worth watching only if you keep that straight.