Passing a peak-throughput test does not prove that a trading platform is ready to launch. A single maximum-rate run can hide slow order acknowledgements, growing queues, fragile downstream services and a recovery process that cannot catch up.
Launch testing needs to establish an operating envelope: what the platform can sustain, how it behaves during short bursts, and what happens when a dependency slows or fails. That means modelling the product and its clients, not simply generating requests until a dashboard turns red.
Start with the product's actual workload
Teams often begin with a headline such as 5,000 orders per second. That figure is only useful if it reflects the launch product, active accounts, instruments, order types and connected services. A platform serving a new CFD product, for example, may see a sharp opening burst, then a lower rate with continuing quote updates, cancellations and margin checks.
Build a workload from expected user journeys and known constraints. Separate order submissions from amendments and cancellations. Include logins, account queries, balance updates, price subscriptions and risk recalculations. A useful first model assigns a share to each action, then varies the mix.
For an initial model, teams might test 40-60% order submissions, 20-35% cancellations or amendments, and the remainder across reads and session activity. These are modelling ranges, not a forecast: use product telemetry or a comparable launch where available.
Concurrency and arrival rate are not interchangeable. A fixed pool of clients that waits for each response can reduce its own request rate as latency rises, concealing overload.
Use an open arrival model for a defined portion of the workload, alongside stateful sessions that maintain realistic subscriptions and account activity. Run separate cases for ordinary activity, a short burst and a sustained busy period.
Write down the assumptions that determine the test: expected active sessions, orders per active account, symbols per session, peak-to-average ratio, and the share of clients on FIX or a web API. If these inputs are uncertain, test low, central and high cases. Teams tracking platform changes and market infrastructure can use broker infrastructure coverage as context, but the workload itself must come from the product being launched.
Measure the order path, not one response time
An order acknowledgement is not an execution, and neither tells the whole story. Measure each important boundary: client to gateway, gateway to risk checks, risk to venue or bridge, and the return path to the client.
Record timestamps with synchronised clocks. Track acknowledgement, rejection and fill separately, and distinguish platform processing time from venue or simulator delay.
The ranges below are typical market ranges for planning and diagnosis, not audited results for any provider. They vary with network distance, venue, product, architecture and the point at which each timer starts. Set launch limits against the service level the product promises, not against a generic number.
| Measure | Typical market range, indicative | What to inspect |
|---|---|---|
| Internal order acknowledgement, p95 | 20-100 ms | Gateway, risk checks, queueing and response path |
| Internal order acknowledgement, p99 | 50-250 ms | Tail latency, pauses, lock contention and noisy neighbours |
| Market-data delivery, p95 | 10-100 ms | Feed handler, fan-out, subscription count and client location |
| Busy-period capacity headroom | 30-50% above forecast peak | Whether latency and error rates remain within limits |
| Queue recovery after a burst | Seconds to a few minutes | Backlog drain rate, duplicate work and stale updates |
Report p50, p95 and p99, plus the maximum queue depth and error rate. A mean can look healthy while a small group of orders waits seconds.
Check the distribution by endpoint, order type and client protocol. If the API is fast but the FIX path is slow, an aggregate percentile can conceal the segment that matters to a particular launch cohort.
Make the test traffic credible
Generated load is only useful when it exercises the same controls as production. A test that skips authentication, risk checks, account state or symbol permissions measures a shortcut. Use representative account and instrument data, realistic subscriptions and the same key network hops. Keep venue behaviour explicit: a simulator should model acknowledgement delay, rejects, partial fills and connection resets rather than returning an immediate success for every order.
Test data can distort results. A small set of accounts or symbols may create hot keys and cache hits that hide database pressure. The opposite problem is unbounded random data, which defeats caches and produces a workload unlike launch traffic. Use a controlled distribution with enough account, symbol and order diversity to reflect the expected product. Reset or version mutable data between runs so one test does not inherit another's state.
Load generators need their own health checks. Monitor generator CPU, network utilisation, open connections, dropped events and event-loop delay.
Validate that the generator emits the planned arrival rate while the platform slows. Reuse the intended connection pattern, including TLS and session renewal where applicable. A single machine behind one source address can trigger rate limits that real clients would not hit, while too few persistent sessions can understate connection-management costs.
- Confirm that generated submissions, cancellations and responses reconcile by order identifier.
- Check that event timestamps, FIX sequence handling and client session behaviour match the production protocol.
- Record the software build, configuration, data set, generator version and test profile for every run.
Keep a low-load control run before and after each major test. It helps separate a platform regression from a generator, network or environment change. Production parity matters, but exact duplication is rarely practical. Document differences such as venue connectivity, cloud instance type, database size and observability overhead, then treat those differences as limits on what the result can prove.
Test degradation and recovery, not only steady state
Production problems rarely arrive as a clean increase in requests. A slow risk service can hold up order submission while a market-data burst fills another queue.
A venue disconnect can trigger retries at the same time that clients reconnect. Run these cases deliberately, with a defined fault and a clear expectation for the affected service.
Inject latency, timeouts and connection loss into dependencies one at a time. Then test combined cases that are plausible for the launch architecture. Watch queue age as well as depth: a queue of 10,000 recent updates differs from 10,000 updates that are already stale. Confirm that backpressure reaches the right boundary, that retries have limits and jitter, and that a circuit breaker does not turn a partial failure into a wider outage.
Recovery deserves its own acceptance criteria. When a dependency returns, check whether queued work drains without starving new orders. Verify that retries do not create duplicate submissions, that sequence gaps are handled, and that clients receive a usable outcome for orders whose status was uncertain during disconnection. Measure time to restore normal latency, not just time to restore a green health check. A service can be technically available while it is still clearing a damaging backlog.
Include the operating team in at least one exercise. Ask them to identify the first useful alert, find the constrained component and apply the documented mitigation. A runbook that says "scale the service" is incomplete if scaling requires a database change, a risk-limit decision or a venue reconnection procedure.
Capture alert delay, diagnosis time and manual steps. These are part of launch readiness, not separate administrative checks.
Set release gates that expose the trade-offs
A go-live decision should use measurable gates agreed before the test. Define the expected peak and burst profile, maximum error and reject rates, latency limits by order path, queue-age limits and recovery time. Set a headroom target against the forecast peak. Typical planning targets often leave 30-50% capacity above expected busy-period load, but the correct margin depends on forecast uncertainty, scaling delay and the cost of excess capacity.
Do not raise throughput by weakening a safety control just to pass a test. If risk checks are the constraint, establish whether the issue is an avoidable database round trip, serial processing or an intentional control. Any change to risk behaviour needs a separate review.
Likewise, increasing queue limits can postpone visible errors while extending the time clients wait for an answer. Report the cost of each proposed fix in capacity, latency, operational complexity and failure exposure.
A useful release record includes the workload definition, test environment differences, raw percentile charts, error and reject breakdowns, queue behaviour, injected faults, recovery results and open risks with owners. Repeat the same baseline after changes to gateways, pricing, risk logic, data stores or deployment topology. A trend across runs is often more actionable than a single pass or fail.
- Block launch if order outcomes cannot be reconciled, tail latency breaches the product limit, or queues keep growing at the forecast peak.
- Require an explicit risk decision if capacity margin depends on manual intervention or a dependency that has not been exercised under load.
- Proceed only when the team can explain both the tested envelope and the conditions that would move traffic outside it.
The objective is not to prove that a platform can survive any imaginable load. It is to know which load it can handle, how it fails beyond that point and how quickly the operation can recover. What assumption about launch traffic or failure behaviour would change your team's go-live decision if the test proved it wrong?
Frequently Asked Questions
How long should a trading platform load test run?
Run short bursts to expose saturation and longer steady periods to reveal queue growth, memory leaks and connection churn. The duration should reflect the product's busy window and recovery requirements. Include repeat runs so results are not dependent on one warm cache or one deployment.
What should a broker measure during load testing?
Measure order acknowledgement and execution separately, with p50, p95 and p99 latency by protocol and order type. Track rejects, errors, queue depth and age, market-data delivery, resource use and recovery time. Reconcile submitted orders against returned outcomes.
How much capacity headroom should a trading platform have before launch?
A typical planning range is 30-50% above the forecast busy-period load, but it is not a universal target. Allow more margin where demand is uncertain, scaling is slow or failure has high operational cost. Confirm that latency and error limits hold at the headroom level, not just that the system accepts the traffic.
Platforms · Software · Providers · Markets