Tick-to-Trade Latency Budget Explained: Where the Microseconds Go
Tick-to-trade is not one number. It is a list of small delays — light in fibre, switch hops, decoding the market feed, deciding, and pushing the order back onto the wire — and the list changes completely with distance. This guide builds the budget leg by leg with the calculator's own default example (1,200 km of fibre: 6,008.32 microseconds, of which propagation alone is 6,000), then runs the identical inputs co-located at 1 km (13.32 microseconds, where the feed handler suddenly matters as much as the physics), and shows why optimising the wrong leg is the most expensive mistake in low-latency work.
The short answer
What is a tick-to-trade latency budget? It is an accounting of every microsecond between a market price update — the tick — arriving at your machine and your order leaving it. The time is listed leg by leg: light travelling through fibre, each switch the packets cross, decoding the market feed into numbers, the strategy deciding what to do, and the order frame being pushed onto the wire. Add the legs and you get the total. Rank the legs and you know which one is actually worth fixing.
Think of it like itemising a journey to the airport. The total trip might be two hours, but that number alone tells you nothing useful. The itemised version — 10 minutes to the station, 50 minutes on the train, 20 minutes in the security queue — tells you exactly where leaving earlier, driving instead, or skipping a queue would actually help. A latency budget is that itemised list for a trade, written in microseconds (millionths of a second) instead of minutes.
Worked budget one: the long route, leg by leg
These are the tick-to-trade calculator's own first-visit defaults on this site — not any real firm's route, and the guide says so plainly. The value is in the arithmetic, which you can reproduce in the tool in under a minute.
| Leg | What it is | Time | Share |
|---|---|---|---|
| Propagation | 1,200 km of fibre at about 5 µs per km (light in glass travels at roughly 200,000 km/s) | 6,000 µs | 99.86% |
| Feed decode | Turning the incoming market-data packet into numbers | 5 µs | 0.08% |
| Switch hops | 2 hops at 1 µs each (cut-through switching) | 2 µs | 0.03% |
| Strategy | The decision logic itself | 1 µs | 0.02% |
| Serialisation | 200-byte frames at 10 Gbps: 200 × 8 ÷ 10,000,000,000 = 0.16 µs, counted twice — tick in and order out | 0.32 µs | 0.01% |
| Total | 6,008.32 µs | 100% |
Read the table from the bottom up. A team could spend a year making the strategy twice as fast and save half a microsecond — 0.008% of the total. They could replace both switches with the fastest hardware sold and save at most the same again. Meanwhile the route itself spends 6,000 microseconds simply because light takes time to cross 1,200 km of glass, and no purchase order changes the speed of light. On a long route there is only one honest lever: make the route shorter, or change the medium — the same 1,200 km by microwave, which travels through air at about 3.34 µs per km (near 299,792 km/s), spends about 4,003 µs on propagation instead, saving roughly 1,997 µs before any repeater hops are added back. That is why long-haul trading routes are built from microwave and millimetre-wave links despite their weather and capacity limits: they are buying back the one leg that matters.
Worked budget two: the same inputs, co-located
Now change exactly one input — the distance, from 1,200 km to 1 km, the sort of distance involved when the trading server sits in the exchange's own building. Every other figure is identical, so the comparison is apples to apples.
| Leg | Time at 1,200 km | Time at 1 km | What changed |
|---|---|---|---|
| Propagation | 6,000 µs | 5 µs | Distance divided by 1,200 |
| Feed decode | 5 µs | 5 µs | Nothing — same handler |
| Switch hops | 2 µs | 2 µs | Nothing |
| Strategy | 1 µs | 1 µs | Nothing |
| Serialisation | 0.32 µs | 0.32 µs | Nothing |
| Total | 6,008.32 µs | 13.32 µs |
The total fell by a factor of about 450 — and the ranking flipped completely. At 1 km, propagation and feed decoding tie at 5 microseconds each, together making up about three quarters of the whole budget. The feed handler, which was a rounding error on the long route, is now co-owner of the budget: swapping a 5-microsecond software decode for the calculator's 2-microsecond FPGA preset saves 3 microseconds, which is 22.5% of the entire co-located budget — against 0.05% of the long-route one. Same optimisation, same 3 microseconds saved, utterly different value. That is the whole lesson of budgeting: a microsecond is not worth a fixed amount. It is worth its share of your total, and the share depends on where you sit.
Which legs the network engineer actually owns
Yours: propagation, hops, and serialisation. Propagation is route engineering — the physical path length, the choice of fibre versus wireless, and where the equipment sits. Switch hops are topology and hardware choice: how many devices the packet crosses, and whether they forward cut-through (the calculator's 1-microsecond preset) or store-and-forward (its 12-microsecond preset — 24 microseconds for the same two hops, which would lift the co-located total above from 13.32 to 35.32 microseconds, about 2.7 times worse). Serialisation is link speed and frame size: the same 200-byte frame takes 0.16 microseconds at 10 Gbps and a tenth of that at 100 Gbps.
Not yours: the exchange's side, and the strategy code. The calculator is honest about what it leaves out — matching-engine response time and exchange turnaround are excluded from the model, because they are the same for every participant and nobody's configuration changes them. Feed decoding sits between the two worlds: choosing an FPGA handler over a kernel software stack is an architecture decision a network engineer should be in the room for, precisely because the budget shows when it matters (co-located) and when it does not (long-haul).
The trap, stated once more with the numbers attached: every optimisation pitch in low-latency networking is a claim about one leg. Before believing any of them, ask which leg, how many microseconds it saves, and what share of your current total that is. Half a microsecond off the switches of a 6,008.32-microsecond budget is a 0.008% improvement wearing a five-figure price tag. The same money spent shortening the route — or moving the server — is the only spending the arithmetic respects.
One last honesty note, which the calculator itself prints: these budgets model the quiet, best-case path. Production latency is the tail — the 99th-percentile time under bursts and host jitter — and it is always worse than the paper sum. The budget's job is to rank the legs and kill bad spending before it happens. Measuring the real tail, with hardware timestamps, is the job that comes after.
Try it yourself
Open the free tick-to-trade latency calculator and check the default budget yourself — 1,200 km should give you the 6,008.32-microsecond total built in this guide, with propagation named as the dominant term. Then change only the distance to 1 km and watch the waterfall re-rank itself: 13.32 microseconds, with feed decoding suddenly tied for first place. Try the FPGA decode preset (2 µs) at both distances and compare what the same saving is worth. For the wider picture — why each of these legs exists and how engineers measure the real tail instead of the paper sum — read the network engineer's guide to latency, and for the bypass techniques that shrink the decode and strategy legs, kernel bypass basics for HFT networks.
- A tick-to-trade budget is addition, leg by leg: in the calculator's default example — 1,200 km of fibre, 2 switch hops, a 5-microsecond feed decode, a 1-microsecond strategy, and 200-byte frames at 10 Gbps counted twice — the total is 6,008.32 microseconds, and propagation alone is 6,000 of them (99.86%). On a long route, physics owns the budget and no switch upgrade can matter.
- Change only the distance to a co-located 1 km and the same inputs total 13.32 microseconds — and the ranking flips: propagation (5 microseconds) and feed decoding (5 microseconds) tie as the biggest legs, so shaving the feed handler now beats shaving the network.
- The network engineer owns propagation (route distance and medium), switch hops, and serialisation (link speed and frame size). The feed handler and strategy code belong to the software side — a budget that separates the two stops each team optimising the other team's leg.
- Optimising the wrong leg is nearly free of effect: cutting half a microsecond of switch latency from the 6,008.32-microsecond budget changes the total by about 0.008%. Always rank the legs before spending anything.