Trading platform load testing before a product launch

Engineer monitoring server performance during trading platform load testing
Photo by panumas nikhomkhai on Pexels

Start with the cost of a missed launch

10 people held for four hours after a failed launch test tie up £3,000-£6,000 at typical fully loaded internal rates of £75-£150 an hour, before missed trading or client remediation. That group may include engineering, dealing, operations and support staff. A test plan is not free, but a small, controlled run is usually cheaper than discovering a bottleneck while clients are placing orders.

For a broker or prop firm, the target is not a headline number of virtual users. It is evidence that the complete trading path can handle the launch workload within agreed response times and without losing, duplicating or misordering state. That path can include authentication, account and margin checks, price distribution, order routing, execution reports, position updates and audit storage.

Start by agreeing what is changing: a new instrument, a large client cohort, a promotion, a platform migration or a new liquidity route. Each creates a different demand profile.

A mobile onboarding campaign may stress authentication and account creation; a new product with volatile prices may put more pressure on market data fan-out, risk checks and order amendment traffic. Define the decision the test must support before choosing a tool.

Compare the available approaches

There are four common routes. Teams can write and operate their own load generator, rent a testing service, engage a specialist provider, or replay production-shaped traffic against a safe environment.

These can be combined. The cost ranges below are typical market estimates, not audited figures for a named provider. They exclude existing platform licences and vary with region, scale and test duration.

ApproachTypical cost rangeUseful forMain trade-off
In-house scripts and runners£5,000-£25,000 initial build, plus £200-£3,000 per substantial runRepeated regression tests and custom protocolsNeeds engineers to maintain realistic scenarios, data and generators
Cloud load-testing service£500-£5,000 a month, plus roughly £200-£5,000 for test infrastructureQuickly generating distributed HTTP, WebSocket or API trafficProtocol limits, data transfer charges and shared-service constraints need checking
Specialist managed campaign£5,000-£30,000 per campaignA fixed launch deadline or specialist FIX and trading expertiseScope and access must be agreed early; the firm still owns production readiness
Production-shaped replay or shadow traffic£1,000-£10,000 in incremental test infrastructure, plus engineeringValidating real message shapes and event mixes in a controlled environmentRequires sanitised data and protections against sending live orders

In-house tooling often makes sense for a platform with a stable protocol and recurring releases. A cloud service can shorten setup time, but a browser-oriented service may not generate FIX sessions or reproduce stateful order flows correctly.

Managed testing brings experience with test design and traffic generation, but does not remove the need for the firm's own risk controls and acceptance criteria. A useful overview of the systems these tests need to cover sits alongside broker infrastructure coverage.

Model the trading journey, not just concurrency

Concurrent sessions are a useful capacity measure, but they say little about order-path load. A thousand users who watch prices and place one order each create a different workload from a smaller group sending frequent cancel-and-replace requests. Specify rates by action and message type. Include realistic idle periods, bursts and reconnects.

Build a workload mix from product assumptions or sanitised production telemetry. A representative scenario might include:

  • Logins, token refreshes and account or instrument queries during the opening ramp.
  • Subscription changes and market-data updates, including fan-out to multiple sessions.
  • New orders, rejects, cancels and amendments, with the expected mix of order types.
  • Risk and margin checks, execution reports, position updates and balance refreshes.
  • Disconnects, retries and reconnects after a network interruption or gateway restart.

Keep rates explicit. For example, define 2,000 active sessions, 300 new orders per second and 500 amendments per second as a test profile only if those figures reflect the planned cohort. They are not interchangeable measures, and they should not be presented as a general broker benchmark. Capture the distribution across accounts, instruments and symbols: one heavily subscribed instrument can create a hot partition even when total traffic appears modest.

Use production-shaped identifiers and market-data sequences where possible, but remove personal data and credentials. Make the generator stateful.

It should know whether an order is open, rejected, partially filled or cancelled, and send only valid next actions. Otherwise the test may spend its capacity generating invalid requests that a gateway rejects before the services that need testing see them.

Match each test to a failure mode

A baseline load test checks expected launch traffic over a steady period. A ramp test raises demand in measured steps and shows where latency or errors begin to climb. A spike test checks a sudden burst, such as a large cohort logging in together.

A soak test runs for hours to expose memory growth, queue accumulation, connection leaks and scheduled jobs. A stress test goes past expected demand to find a limit and observe how the platform fails.

Do not treat a single peak-throughput result as proof of readiness. Record latency distributions at each step, especially p95 and p99, alongside error rate, order acknowledgement time, queue depth, CPU, memory, database connections and network throughput.

Track both the client-visible response and the internal stages. A fast API response can conceal a delayed downstream execution report; a healthy average can conceal a p99 that breaches the product's service objective.

Set pass criteria before the run. They should specify acceptable response times for each user journey, maximum error and reject rates, queue behaviour, and whether the platform recovers after demand falls.

Use existing service objectives where they apply. If they do not exist, agree budgets with dealing and operations based on the product and execution route, rather than selecting an arbitrary latency target after seeing the results.

Run against a production-like topology: similar application replicas, database shape, message broker configuration, network path and autoscaling rules. A staging environment with half the database capacity is not a valid proxy unless its limits are understood.

Confirm that any external venue, liquidity provider or payment integration is simulated or explicitly authorised. Keep test accounts and instruments separated from live trading.

Use a controlled run and a release checklist

Before increasing load, prove that the test itself is not the bottleneck. Load generators need headroom, stable clocks and enough network capacity.

Run a small calibration and compare generator CPU, connection counts and outbound bandwidth with the application's measurements. If one generator saturates at 70 per cent CPU, a flat throughput curve may reflect the test rig rather than the platform.

Coordinate the run with operations, dealing and any relevant suppliers. Agree a named owner, a stop condition and a channel for incident decisions. Disable real order routing unless the test is formally authorised. Use synthetic accounts, capped test balances and deterministic data where possible. Make sure logs and metrics retain correlation identifiers across gateway, risk, order management and execution services, so a slow acknowledgement can be traced rather than guessed at.

  1. Write down the launch cohort, peak session count, order rates, market-data profile and expected ramp.
  2. Choose the specific user journeys and message mix; include rejects, amendments and reconnects.
  3. Confirm test environment capacity, data sanitisation, routing safeguards and supplier approvals.
  4. Run a low-rate calibration, then a baseline before testing the expected peak and a measured overload.
  5. Capture p50, p95 and p99 latency, errors, queue depth, resource use and downstream completion.
  6. Repeat the peak run after fixes, and test recovery, autoscaling and restart behaviour.
  7. Publish the evidence, open risks, owner and release decision in a record operations can use.

Make the release gate operational

A passing test is a release input, not a guarantee that live traffic will match the model. Document which assumptions were exercised, which dependencies were mocked and where headroom remains. Set a launch ramp that operations can observe and control. Useful controls include cohort limits, instrument-level throttles, a tested rollback path and dashboards for order acknowledgements, rejects, risk-service latency and queue growth.

Define who can pause the ramp and what signal triggers that decision. A steadily rising queue or a growing gap between order acceptance and downstream state updates can be a stronger warning than a brief CPU peak.

Check alert ownership and on-call coverage before release. The runbook should say how to reduce new sessions or order rates without leaving open orders, stale positions or client-facing status inconsistent.

After launch, compare actual session and message rates with the test profile. Record where the model was wrong and feed that evidence into the next release.

Production observation should use the same service objectives as the test where practical, while keeping live safeguards in force. Stop doing these things before the next launch:

  • Stop reporting only virtual-user counts or peak requests per second.
  • Stop testing with a single happy-path order and calling it a trading workload.
  • Stop running uncoordinated load against live venues or shared production data.
  • Stop approving a release without named thresholds, owners and a tested pause path.

Frequently Asked Questions

How far ahead of launch should a broker load test?

Schedule the first realistic test several weeks before launch, leaving time to fix bottlenecks and repeat the run. A specialist campaign may need one to three weeks of preparation, particularly if access, data or supplier approvals are required.

What should a trading platform load test measure?

Measure client-visible latency and errors across login, market data, order submission and downstream execution updates. Also track p95 and p99 latency, queue depth, resource use, rejects and recovery after a burst or service restart.

Can a broker use production traffic for load testing?

Production-shaped, sanitised traffic can improve realism, but replay it in an isolated environment or use carefully controlled shadowing. Prevent test orders from reaching live venues, and remove personal data, credentials and other sensitive fields.

Is a cloud load-testing service enough for FIX platforms?

Not necessarily. Confirm that the service can maintain stateful FIX sessions and generate valid order sequences, rather than only HTTP requests. Teams may need a custom generator or a specialist provider for protocol-specific scenarios.

How much does trading platform load testing cost?

Typical market ranges run from a few hundred pounds for test infrastructure to £5,000-£30,000 for a specialist campaign. In-house engineering time, platform access, data preparation and repeat runs can add materially to the total.