Systems & desktop engineering · Fintech

Trading System API (Qt Desktop)

Sevendyne built a remote C++/Qt engineering team for trading-system API programmes, then that team worked with client trading leads to design and ship native desks — core algorithms, multi-window operator surfaces, and market-data paths wired into proprietary libraries.

3-minute CTO brief

We staffed a founding C++/Qt pod and placed them with trading programme stakeholders — daily standups, joint PR reviews on threading changes, and pairing with client library owners. The result was a native Qt desk wired directly into existing C++ trading libraries — not a web shell. Market ticks never block the UI thread; strategy code owns order state on worker threads; the operator sees consistent books because updates are queued, not polled.

Complexity: Threading, lock discipline, UI refresh budgets
Failure mode: Stalled UI during volatile tape → missed hedge
Our bet: Thin Qt view layer, fat native algo core

Native desktop · concurrency · low latency

Architecture — how data moves

Three lanes: ingest thread pulls normalized ticks, strategy thread mutates books and emits order intents, UI thread renders grids and depth ladders from immutable snapshots delivered via Qt::QueuedConnection.

Design decisions (why we chose this)

Decision	Alternatives considered	Why we picked it
Qt/C++ desktop	Electron, .NET WPF	Direct link to proprietary C++ libs; no IPC latency; dense grid performance.
Queued signals to UI	Cross-thread mutex on every tick	UI never blocks on feed; coalesce bursts before repaint.
Per-instrument single writer	Global order lock	Scales with parallel books; avoids convoy on hot symbols.
Snapshot-based widgets	Live pointer into algo memory	Prevents use-after-free if strategy reallocates during paint.

Code shape (representative)

UI receives coalesced book updates — strategy thread never touches widgets:

// Strategy thread → UI (queued)
void BookEngine::onTick(const Tick& t) {
  applyToBook(t);
  if (shouldRepaint(t.symbol))
    emit bookUpdated(t.symbol, snapshot(t.symbol)); // QueuedConnection
}

// UI thread only
void DepthLadder::onBookUpdated(Symbol s, BookSnap snap) {
  render(snap); // no locks; snap is immutable
}

Reliability tactic: on feed disconnect, UI shows stale banner and blocks new orders until snapshot resync completes — operators never trade on partial state.

Production outcomes

Multi-window desk with sub-second refresh on active symbols during peak tape.
Zero UI-thread blocking from market I/O after queued-signal refactor.
Foundation for later embedded/Qt programmes (navigation, industrial HMIs).

Download technical brief (PDF) Schedule a technical review