Levent Gündogdu

Senior trading-systems engineer  /  C++ & CUDA, native Bayesian optimisation, low-latency execution, HPC

I build native, measurement-driven trading systems: tick-level backtesters, GPU-accelerated optimisers, real-time execution engines, and a 3D observability deck rendering real-time telemetry. For the last three years I have designed and run Fathom, an integrated systematic trading platform, on my own capital - trading my own book while building it. It is the third trading system I have built: the first, written in Java, traded live in 2006; the second ran cloud-native on GCP and taught me why this one is C++ on bare metal.

Current work: Fathom

An integrated systematic trading platform: tick-level backtesting, GPU-accelerated Bayesian optimisation, a live C++ execution engine, 3D telemetry, and an autonomous monitoring loop. Self-directed and funded from personal capital.

Native execution engine
The live decision path, rewritten in single-host C++ under a measurement-first discipline. Shared-memory transport and journaled durability are the end state; CUDA-resident decisioning is the final step.
The hot path runs C++ end-to-end in production: market-data ingest - a clean-room broker wire-protocol client with a zero-allocation protobuf codec - through strategy decision, live for all 13 trading tracks (cut over track-by-track after a shadow-validation burn, gated by a custom divergence comparator with per-track rollback), to order-event commit (cut over after replay parity against captured production events). Superseded engines are deleted on cutover. Eleven shared C++ libraries. Measurement landed first: per-hop latency histograms across the live path, single-digit-millisecond decision p99; every cross-host hop engineered out of the hot path. The shared-memory tick path is now live in production - a single-writer broadcast ring with seqlock-validated reads and optional per-slot CRC32C, benchmarked across Apple Silicon, AMD Zen, and Intel hybrid cores - on the path to a sub-millisecond decision p99.
Native CUDA Bayesian optimisation engine
Gaussian-process Bayesian optimisation, rebuilt from scratch in C++/CUDA to tune strategy parameters and validated against a PyTorch/BoTorch baseline.
Matern 5/2 GP, qLogEI acquisition, parallel multi-stream L-BFGS-B. 33x faster end-to-end than the BoTorch baseline on a V100 - 8.1 s to 243 ms per iteration at d=19, n=256. 121 unit tests plus 28 SciPy reference checks to machine epsilon. Runs as elastic GPU workers pulling jobs over NATS across a six-GPU, three-architecture fleet (RTX 4090 / Ada, V100 / Volta, P100 / Pascal) spanning the production cluster and an external worker host.
Tick-level backtester
A C++20 engine that replays historical market data tick-by-tick through the production strategy chain.
~11K lines of C++20, 133 unit tests, a 10-plugin ordered decision chain. Runs against a TimescaleDB market-data store with 365-day raw-tick retention.
MCP server + agentic operations
Three Model Context Protocol servers expose the platform and its toolchains to LLMs: two agents sweep state autonomously and publish findings, the same tools drive LLM-written analyst tear sheets, and agents can build, profile, and benchmark through the CUDA and Swift toolchain servers.
46 introspection tools across trading, analytics, market data, infrastructure, and experiments. Two agents (infrastructure and trading) run a local LLM, publishing deduplicated findings over NATS. The same tool layer generates daily and weekly tear sheets - execution-quality and portfolio metrics computed live (operator-invoked). Scope-based auth; fixture-tested tools.
Real-time 3D telemetry dashboard
A Swift / RealityKit dashboard that renders live platform state as procedural 3D geometry, fed by a custom binary WebSocket protocol.
~27,500 lines of Swift, 10 binary codec versions across 8 stream types. Radar webs, voxel grids of optimisation trials, gauge arcs, atlas-based glyph text. Profiled and optimised: dirty-flagged mesh caching, frame-budgeted scheduling, signpost instrumentation.
Platform & infrastructure
Not just the trading application: the whole stack is self-built and operated end-to-end as infrastructure-as-code.
6-node bare-metal Kubernetes (Cilium eBPF, kube-vip HA) + a dedicated GPU host, the whole stack as OpenTofu IaC across dev and prod: Rook/Ceph, three PostgreSQL clusters (one TimescaleDB) with offsite WAL archiving to S3 and point-in-time recovery, NATS HA, Vault, cert-manager TLS, GPU Operator. Self-hosted supply chain (OneDev CI, Harbor + Trivy CVE scanning), full OpenTelemetry to VictoriaMetrics / VictoriaLogs / Tempo.
Reliability & exchange connectivity
The correctness layer under a money-handling system: explicit failure semantics, reconciliation, broad venue connectivity, and a test suite that gates every change.
A durable ordering contract - at-least-once delivery, serializable transactions, retry-on-conflict - so concurrent writers can't corrupt order or position state; broker timeouts never assert an unknown outcome. Live multi-broker order execution, with integrations to five venues plus two from-scratch native protocol implementations - a FIX 4.4 engine (session layer + order-entry / market-data) and a clean-room client for a proprietary broker wire protocol, live on the market-data path. The newest broker adapter is C++; its balance reconciler is the stack's first Rust service, built AI-assisted under my direction. FIX 4.2 is the forward integration path for the venues ahead. Deep C++ test suites (133 simulator + 121 CUDA-optimiser cases), real fixtures over mocks, simulator-vs-live parity as a merge gate, and a 95,000-price grid scan that caught a floating-point broker-rejection bug.

Writing

Contact

levent@feature-it.com | send mail

linkedin.com/in/levent-guendogdu