Tick-To-Trade Latency

An exchange publishes a price update. Somewhere in the world, dozens of firms receive that same packet at effectively the same instant, and a race begins: whoever reacts and gets an order back to the exchange first gets to trade on the new information; everyone slower trades against a price that's already stale. Tick-to-trade latency is the name for that race clock — the time from "packet arrives" to "order leaves your system" — and in modern HFT it's measured in microseconds (millionths of a second) or even nanoseconds.

The path the clock measures

1. Wire to NIC: the market data packet physically arrives at your network card.
2. Parse: your system decodes the exchange's binary protocol into a usable price/size update.
3. Strategy logic: a decision is made — does this update change what you want to quote or trade?
4. Order construction: build the outbound order message in the exchange's required format.
5. NIC to wire: the order leaves your network card back toward the exchange.

Tick-to-trade is the sum of all five steps. A firm running standard software on a general-purpose server might take 50-100 microseconds end to end. A firm running specialised hardware might take under 1 microsecond. That hundred-times difference determines who is first in the queue on the next order book event, every single time both firms react to the same tick.

Worked example: who gets the fill

Two firms, A and B, both run strategies that widen their quotes the instant a large trade prints on a correlated futures contract, because that trade signals the equity is about to move. The futures trade prints at time $t_0$.

Firm	Tick-to-trade	Order arrives at exchange
A (FPGA, colocated)	2 microseconds	$t_0 + 2\mu s$
B (software, colocated)	40 microseconds	$t_0 + 40\mu s$

Both send a cancel-and-replace to pull their stale bid before someone can hit it at the old, now-too-generous price. Firm A's cancel arrives 38 microseconds before Firm B's. If a third party's marketable sell order arrives at, say, $t_0 + 15\mu s$ — plausible, since informed order flow often reacts fast too — it finds Firm A's bid already pulled, but Firm B's stale bid is still resting and gets hit. Firm B just bought at a price that was already known to be too high, purely because it was 38 microseconds slower to react to public information.

Where the microseconds actually go

Parsing and strategy logic used to dominate; today, with FPGAs In Trading Systems handling parsing and simple decisions in hardware, the bottleneck has shifted to physical distance (speed of light down fiber or through microwave links) and the exchange's own internal matching latency, both largely outside any single firm's control. This is why colocation — renting rack space physically inside or adjacent to the exchange's data center — is worth paying for even before touching the software: a 50-meter cable versus a 50-kilometer one is a difference measured in whole microseconds, larger than most firms' entire software stack.

In interviews

Be ready to name all five stages of the pipeline, not just "it's fast hardware" — interviewers are checking whether you understand latency as a chain where the slowest link sets the total, not a single knob. The natural follow-up is Latency Arbitrage: what a faster firm actually does with the time it wins.