Built for traders who don't settle
A modern exchange backend with event-driven architecture, low latency matching, durable recovery, real-time streams, and developer-first APIs.
A clean execution pipeline from intent to recovery.
The public API stays separate from the matching hot path. Commands are ordered, events are replayable, and durable state catches up through workers.
The parts that matter in a serious exchange backend.
Built from simple service boundaries, explicit persistence, and a matching engine that can be reasoned about under load.
Event sourcing
Event sourcing
Commands and fills are persisted as ordered events execution.
Snapshot recovery
Snapshot recovery
Orderbooks restore from compact snapshots & replay only the stream events.
Low-latency matching
Low-latency matching
The hot path keeps books in memory and avoids relational writes.
Live market data
Live market data
Trade prints, orderbook deltas, account updates, and mark prices stream in real time.
API-first access
API-first access
Stable REST payloads, explicit errors, and predictable contracts keep integrations clean.
Risk controls
Risk controls
Margin, funding, liquidation, and insurance workflows stay isolated from order matching.
Service boundaries
Service boundaries
Each service owns a focused responsibility, making the exchange easier to scale.
Fast observability
Fast observability
Stream lag, health checks, worker state, and market-level signals are built for quick diagnosis.
Build around hot path
The engine consumes ordered commands, keeps orderbooks in memory, and delegates persistence to idempotent workers.
Designed around sequential per-market command processing.
No relational writes in the matching engine hot path.
Idempotent side effects, durable outbox, and replayable streams.
Predictable APIs for teams that ship trading systems.
Order submission, market discovery, account queries, and WebSocket streams use explicit contracts with stable errors. The backend is approachable in local memory mode and production-ready with Postgres, Redis Streams, and workers.
POST /api/orders
{
"marketId": "BTC-PERP",
"side": "BUY",
"type": "LIMIT",
"price": "100000",
"quantity": "1",
"timeInForce": "GTC",
"postOnly": true,
"leverage": 10
}A pragmatic path from reference backend to production surface.
Future milestones focus on integration quality, operator confidence, and scaling the same clear architecture.
Public SDKs
Typed clients for order entry, market data subscriptions, and account state.
Multi-Market Scaling
Shard matching workers by market while preserving deterministic command order.
Institutional Controls
API keys, session policies, and operator-level observability for production desks.
Status Surface
Health checks, stream lag, worker state, and market-level incident visibility.
Build on a Modern Exchange Infrastructure
Launch with a backend shaped around deterministic matching, durable persistence, real-time market streams, and operational clarity.
