Packet Path/

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.

Latency · Intermediate · 11 min · November 10, 2026

Editorial illustration on a dark teal background: a glowing pulse entering from the left, travelling along a fibre line through two small switches into a stack of servers, with a second glowing pulse leaving to the right.

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.

In plain EnglishTick: one market-data update — a price or quantity changed. Tick-to-trade: the full loop from that update arriving to your order going out. Propagation: the travel time of light itself through fibre or air — set by distance and the medium, not by equipment quality. Serialisation: the time it takes to physically push a frame's bits onto the wire — bigger frame or slower link means longer. Feed handler: the software (or hardware) that decodes the exchange's market-data format into numbers the strategy can use. Co-location: renting rack space in the same building as the exchange's matching engine, so the distance leg nearly vanishes.
The 1,200 km budget: one leg is 99.86% of the total Propagation: 6,000 µs 1,200 km of fibre Feed decode: 5 µs Strategy: 1 µs Switches: 2 µs Serialisation: 0.32 µs Total: 6,000 + 5 + 1 + 2 + 0.32 = 6,008.32 µs (about 6.01 ms). Everything except propagation adds up to 8.32 µs — a rounding error. On a long route, distance is the budget. The rest is commentary.

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.

LegWhat it isTimeShare
Propagation1,200 km of fibre at about 5 µs per km (light in glass travels at roughly 200,000 km/s)6,000 µs99.86%
Feed decodeTurning the incoming market-data packet into numbers5 µs0.08%
Switch hops2 hops at 1 µs each (cut-through switching)2 µs0.03%
StrategyThe decision logic itself1 µs0.02%
Serialisation200-byte frames at 10 Gbps: 200 × 8 ÷ 10,000,000,000 = 0.16 µs, counted twice — tick in and order out0.32 µs0.01%
Total6,008.32 µs100%

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.

LegTime at 1,200 kmTime at 1 kmWhat changed
Propagation6,000 µs5 µsDistance divided by 1,200
Feed decode5 µs5 µsNothing — same handler
Switch hops2 µs2 µsNothing
Strategy1 µs1 µsNothing
Serialisation0.32 µs0.32 µsNothing
Total6,008.32 µs13.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.

At 1 km the ranking flips: decode ties propagation Propagation: 5 µs 1 km of fibre Feed decode: 5 µs Now co-biggest leg All other legs: 3.32 µs Switches + strategy + wire Total: 13.32 µs. An FPGA decode at 2 µs cuts it to 10.32 µs. The same 3 µs saving was 0.05% of the long-route budget. Rank the legs first. Then spend.

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.

Fact-check sourcesBoth budgets are the tick-to-trade calculator's own figures on this site, recomputed by hand: the defaults are 1,200 km, 2 switch hops at 1 µs, 0 regen hops, 5 µs feed decode, 1 µs strategy, and 200-byte frames at 10 Gbps. Propagation uses the tool's fibre figure of about 5 µs per km (light in fibre at roughly 200,000 km/s): 1,200 × 5 = 6,000 µs. Serialisation is 200 × 8 ÷ 10,000,000,000 = 0.16 µs per frame, doubled to 0.32 µs because the tool counts the tick in and the order out. Totals: 6,000 + 2 + 5 + 1 + 0.32 = 6,008.32 µs, with propagation at 99.86% of it; at 1 km, 5 + 2 + 5 + 1 + 0.32 = 13.32 µs. The microwave figure uses the tool's own near-light-speed rate of about 3.34 µs per km (299,792 km/s): 1,200 km is about 4,003 µs, saving about 1,997 µs. The switch and feed-handler presets (cut-through about 1 µs, store-and-forward about 12 µs, FPGA decode about 2 µs) are the calculator's own preset buttons. No real firm's route, and no vendor or exchange latency figure, is claimed anywhere in this guide.

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.

Key takeaways

Keep reading