Glossary term
What Is Trading Infrastructure? A Layer-by-Layer Definition
Trading infrastructure explained in five layers: matching, market data, risk, connectivity, and hosting and disaster recovery, with buyer questions and tests.
Definition
Trading infrastructure is the set of systems that take orders, match or route them, carry market data, control risk, connect to counterparties and keep the platform running. This entry splits it into five layers: matching, market data, risk, connectivity, and hosting and disaster recovery.
Key takeaways
- Trading infrastructure splits into five layers: matching, market data, risk, connectivity, and hosting and disaster recovery.
- Each layer needs its own evidence, such as a written rule, a replay, a test with named counterparties, a fault test or a failover drill.
- Risk checks read market data and matching depends on input order, so test the handoffs between layers, not only the layers.
- Recovery objectives are set per deployment. This page gives no latency, uptime or recovery figures.
- The five-layer split is this site's own framing, not an industry standard. Requirements depend on the market, the instruments and the regulator.
The five layers of trading infrastructure
A gap in any layer can stop orders, prices or fills, so ask for evidence on all five.
Trading infrastructure is easier to buy, test and budget for when it is split into layers. The layers of trading infrastructure used here are matching, market data, risk, connectivity, and hosting and disaster recovery. The five-layer split is this site's own framing, not an industry standard. The site's publisher builds its own trading platform, so treat the split as one vendor's view.
| Layer | What it does | What to ask a vendor | What to test before go-live |
|---|---|---|---|
| Matching | Pairs orders under one written priority rule and reports each fill. | Priority rule per book, input sequencing, journal replay, standby takeover. | Replay recorded inputs and compare fills. Test each priority rule on crossing books. |
| Market data | Receives feeds, normalizes and timestamps them, stores them and flags gaps. | Feed list, timestamp source, gap and stale-price rules, entitlements, retention. | Replay a full trading day, inject a feed gap, and confirm the flag and recovery. |
| Risk | Screens orders before acceptance: price collars, size and credit limits, duplicate checks, kill switch. | Where each check runs, who sets the limits, and which order paths skip checks. | Send orders that breach each limit. Trigger the kill switch and check its audit record. |
| Connectivity | Holds sessions to clients, liquidity providers and venues, over FIX or an API. | FIX versions, certification with each named counterparty, recovery after a disconnect. | Test logon, resend and reconnect with working orders open, then test reject paths. |
| Hosting and disaster recovery | Keeps processes running, restarts them after a fault and fails over to standby. | Failure domains mapped, recovery targets set per deployment, named failover sign-off. | Crash a process during working orders. Run a failover drill and reconcile open orders. |
Matching: one written rule for every book
Two priority rules can fill the same book differently, so the rule must be named and tested.
The matching layer holds the order book for each instrument and pairs orders when prices cross. This site's core-engine architecture page describes two priority rules. Price-time priority fills the earliest order first at each price. Pro-rata splits the fill across resting orders at that price in proportion to size. The same page says each accepted input and output should carry a sequence number, and that a tested recovery should rebuild the book from a snapshot and the journal and check the result against recorded fills. That is the design view to read against this layer. Before you set any timing target, read the high-latency definition in this glossary.
Market data: feeds in, checked prices out
Risk checks and matching both read prices, so a late or gapped feed can make a correct engine give wrong answers.
The market-data layer normalizes feeds from providers and venues, timestamps them, stores them and passes them on. Tick-by-tick records keep every quote and trade update, and the tick-by-tick data entry in this glossary explains them. Ask where each timestamp is set. A timestamp taken after a message has waited in a queue hides a delay that a client will notice. Test gap detection and stale-quote flags with injected faults, not only clean replays.
Risk: screening orders before they reach the book
Pre-trade controls run before acceptance. Placement and thresholds are compliance decisions, so test evidence matters more than the feature list.
The core-engine architecture page lists the usual pre-trade controls: price collars, order size limits, credit or margin limits, duplicate-order checks and a kill switch. In the United States, SEC Rule 15c3-5 covers broker-dealers with market access. The SEC's compliance guide says their controls must, among other things, be reasonably designed to systematically limit the firm's financial exposure from market access and to prevent the entry of orders that exceed appropriate pre-set credit or capital thresholds or appear to be erroneous. The words "prevent the entry" put these controls before order entry, not after it. The related guide on pre-trade risk checks covers placement and timing trade-offs.
Connectivity: sessions to clients, providers and venues
A production problem can start at a session, not only inside the engine.
Counterparties may connect over FIX, an open standard that the FIX Trading Community develops and maintains, or over a REST or WebSocket API. Ask each counterparty how it implements session recovery, and test that implementation, because a specification does not show how it behaves under load. Run reconnect tests with working orders open, to see how a lost or repeated message is handled. The FIX protocol entry in this glossary covers the basics, and the related guide on FIX, REST and WebSocket APIs compares the three on session, order entry and recovery.
Hosting and disaster recovery: keep every layer running
A matching process that restarts without its order state has failed, even though it is running.
Hosting covers process isolation and resource limits, which reduce how far one runaway strategy can reach into a shared host. It also covers a supervisor that watches running processes, and replicated order state so a failover keeps the order log consistent. Disaster recovery covers losing a site, zone or provider. Treat it as a failure-domain review: map shared power, network, provider, identity and data dependencies before calling a design redundant. Recovery time and recovery point objectives belong in the contract, each backed by a test.
How the layers depend on each other
A layer can pass its own tests and still fail the platform.
Orders flow from connectivity to risk to matching, and market data feeds both risk and matching. Two dependencies need their own tests. The first is risk on market data: a risk check that reads a stale reference price is not working, even when it passes orders. The second is matching on hosting and disaster recovery: a matching process that restarts without sequence state can publish a different book from the one clients last saw. Test each handoff as its own case, with an owner for each.
- Risk: rejected orders never reach matching.
- Market data: a stale reference price stops or flags the order.
- Matching to connectivity: each fill is reported once, even after a reconnect.
- Hosting: a restart during working orders recovers the book and open orders.
How this differs from financial market infrastructure
The CPSS-IOSCO principles use financial market infrastructures as a collective label for systemically important payment systems, central securities depositories, securities settlement systems, central counterparties and trade repositories. That is not the trading infrastructure meaning used on this page, so check which meaning a document uses before you compare requirements.
Limitations and risk notes
The five-layer split is this site's own framing, not an industry standard. Requirements depend on the market, the instruments traded, the client base and the regulator, so confirm them with qualified counsel and your compliance team. This page gives no latency, throughput, uptime or recovery figures, and none should be inferred from it. Nothing here promises a result, and nothing here is legal, regulatory, tax or investment advice.
Frequently asked questions
What is trading infrastructure?
Trading infrastructure is the set of systems that take orders, match or route them, carry market data, control risk, connect to counterparties and keep the platform running. It covers the software and the hosting it runs on. The regulatory term financial market infrastructures has a different meaning, which this entry explains in its own section.
What are the five layers of trading infrastructure?
The five layers are matching, market data, risk, connectivity, and hosting and disaster recovery. Matching pairs orders under a written rule. Market data carries and checks prices. Risk screens orders before acceptance. Connectivity holds sessions to clients and counterparties. Hosting keeps the layers running and recoverable. The split is this site's own framing, not an industry standard.
Which layer should a buyer test first?
Start where orders flow: risk checks and connectivity, because a missed check or a dropped session reaches clients at once. Then test market data faults, matching replay and failover. Finish with an end-to-end drill before go-live, and repeat it after each release that changes the order path.
What should a buyer ask a trading infrastructure vendor first?
Ask for evidence on the build you would buy, not a feature list. Ask which FIX versions are certified with your named counterparties, where each risk check runs, how the book is sequenced and replayed, which feeds the market data layer uses and how it timestamps them, and what the last failover test showed.
Primary sources and further reading
These sources support the definitions used on this page. They do not endorse Orrnn or establish that any product complies with the referenced material.
- Principles for financial market infrastructures
CPSS and IOSCO; published by the Bank for International Settlements in its CPMI Papers series
CPMI Papers No 101, dated 16 April 2012. Applies the label financial market infrastructures to payment systems, central securities depositories, securities settlement systems, central counterparties and trade repositories, a different meaning from this term. Checked 10 November 2026.
- Small Entity Compliance Guide: Rule 15c3-5
U.S. Securities and Exchange Commission
Explains the risk controls required of broker-dealers with market access, under a rule adopted on 3 November 2010. Checked 10 November 2026.
- FIX Protocol
FIX Trading Community
Describes the FIX Protocol as a global, open standard, developed and maintained by the FIX Trading Community. Checked 10 November 2026.
- Matching Engine Architecture: Order Lifecycle
Orrnn architecture page
Orrnn's own description of the matching layer: priority rules, sequenced inputs, journal replay and pre-trade controls. Not a third-party assessment. Read 10 November 2026.
Related reading
Matching Engine Architecture
How a matching core sequences inputs, applies a priority rule and reports fills.
Read →Pre-Trade Risk Checks Without Adding Latency
Where pre-trade risk checks sit in the order path, and what they add.
Read →WebSocket vs REST vs FIX: Which Trading API to Use
How the three connection types differ on session, order entry and recovery.
Read →Trading Infrastructure Checklist: Core Engine, Hosting & Connectivity Specs
A checklist for reviewing trading infrastructure before a launch or vendor choice.
Read →FIX Protocol
Sessions, message anatomy and versions for the connectivity layer.
Read →High Latency Definition
What counts as high latency, read before setting a timing target.
Read →Tick-by-Tick Data
Feeds, storage and timestamps for the market data layer.
Read →