Trading platform development
From signal to order in about half a millisecond, measured in replay.
A trading platform captures market data, runs strategies, checks risk, and sends orders, then shows the desk what is happening. Acasa Labs builds them. Our options trading platform for a confidential client decodes market data at 2.5 µs p50 and goes from signal to order created in about 0.5 ms, measured in tape replay.
The problem
The dashboard should never be the reason an order was late.
A trading system fails in quiet ways. A logging call blocks the event loop during a burst. The dashboard's WebSocket backs up and slows the thread that sends orders. An instrument is identified from a string that changed format. None of it shows up in a demo, and all of it shows up on a busy expiry day. The work is keeping the trading path short, measured, and isolated from everything else that wants its attention.
What we build
- 01
Market-data capture
Feed handling that decodes ticks on its own thread and hands them to the engine safely, with every tick archived for research.
- 02
Execution and order management
An event-driven engine with broker adapters for REST and WebSocket APIs, and the same code path for paper and live.
- 03
Risk before every order
Position caps, per-bar guards, a kill switch, and independent gates that every live order has to pass.
- 04
Desk dashboards and monitoring
Positions, market state, and per-stage latency streamed to a web dashboard, with Prometheus and Grafana alerting.
From production
How the options platform is built.
Nothing blocking on the engine loop
Options trading platformMarket-data decode runs on its own thread and is handed to the engine loop thread-safely. Nothing that can block ever sits on the loop.
A publisher that drops, not blocks
Options trading platformThe publisher feeding the dashboard is bounded and drops when full. It never blocks the trading path, and if the realtime gateway dies, trading does not notice.
Latency in 12 stages
Options trading platformEvery stage is instrumented with exact percentile reservoirs and exported to Prometheus and Grafana with alert rules. Risk checks run at 21 µs p50, measured in tape replay.
Identity from a snapshot, not a string
Options trading platformInstrument identity is read from a snapshot map, never derived from strings, so a change in symbol format cannot quietly point an order at the wrong contract.
Honest trade-offs
Build a platform, or use a broker's?
If you trade a few strategies by hand, a broker's terminal and API will do, and a custom platform is money you do not need to spend. Build your own when strategies run automatically, when you need research, paper, and live on one code path, when latency is measured in microseconds rather than seconds, or when the risk rules are yours and must hold under a burst.
What we reach for
- Rust-core event engine
- Python
- FastAPI
- Redis
- WebSocket, SSE
- Postgres
- Next.js
- Prometheus, Grafana
Proof
Shipped, not pitched.
01Client work
Options trading platform
Microsecond market-data handling for index options, with risk checks that never sleep.
A private trading platform for index options on an Indian exchange: tick capture, research and backtesting, paper and live execution, and a control dashboard. Built for a client's internal use; details are anonymized.
Trading engine · Realtime gateway · Web dashboard
Questions
Trading platform development questions we get asked.
How fast is the platform you built?
In tape replay: market-data decode at 2.5 µs p50 and 8 µs p99, a risk check at 21 µs p50, and about 0.5 ms from signal to order created. Live latency also depends on your broker and your network.
Which markets does it trade?
Index options on an Indian exchange. The client, broker, and strategy details are confidential.
Can you connect to our broker?
If the broker has a documented API, yes. We built a custom adapter for the client's broker's REST and WebSocket APIs, and would do the same for yours after checking its rate limits and order types.
Why Python if speed matters?
The hot path sits on a Rust-core event engine. Python carries strategy logic and tooling, and order logic is kept free of engine imports so it can be ported to Rust when it needs to be faster.
Can the desk see positions in real time?
Yes. Market state streams to a web dashboard through Redis and a WebSocket gateway, throttled per instrument, so the dashboard stays live without slowing trading.
Trading platform development
Tell us where your system is slow.
Or where it would break on a busy day. We will review the architecture and come back with what we would change first.