Senior C++ Engineer (Low Latency) — Crypto Backtes

We are building an AI-first quantitative trading platform and proprietary trading stack spanning US equities and crypto markets. Our infrastructure is designed from the ground up for speed, scale, and statistical rigor — including a high-performance C++ backtesting and execution environment.

We are looking for a
**low-level, performance-obsessed C++ engineer**
to help push our crypto backtesting engine toward institutional-grade speed and realism.

🧠 Role Overview

You will design and optimize the core of our
**event-driven crypto backtesting engine**
, focusing on microsecond-level efficiency, memory discipline, and realistic market simulation.

This is not CRUD work. This is systems engineering for trading.

You should be comfortable working close to the metal and thinking deeply about latency, cache behavior, and data layout.

⚙️ Key ResponsibilitiesEngine & Performance

- Design and optimize low-latency components in modern C++ (C++17/20 preferred)
- Improve backtest throughput (events/sec) and memory efficiency
- Profile and eliminate performance bottlenecks (CPU, memory, cache misses)
- Implement high-performance event-driven simulation frameworks
- Optimize order book replay and trade matching logic
- Ensure deterministic and reproducible backtest results

Systems & Architecture

- Design lock-free / low-contention data structures where appropriate
- Optimize memory layout (SoA vs AoS, cache alignment, pooling)
- Improve multi-threading and parallel backtest execution
- Build high-performance data ingestion pipelines
- Ensure correctness under high event throughput

Trading Realism

- Implement realistic crypto microstructure modeling
- Handle partial fills, slippage, queue position, and latency modeling
- Work closely with quant researchers to support new strategy requirements
- Maintain clean separation between research and execution layers

✅ Requirements (Must-Have)

**Core Engineering**

- Strong C++ (C++17 or newer) in performance-critical systems
- Proven experience in low-latency or high-performance environments
- Deep understanding of:
- CPU cache behavior
- Memory management
- Multithreading & concurrency
- Profiling and benchmarking

**Systems Knowledge**

- Experience with lock-free or wait-free programming
- Familiarity with Linux performance tooling (perf, valgrind, etc.)
- Strong grasp of data structures and algorithmic efficiency
- Experience building event-driven systems

**Domain**

- Experience in one or more:
- Trading systems
- Backtesting engines
- Market data processing
- Exchange/order book systems
- HFT or low-latency infrastructure

⭐ Strong Plus

- Crypto market microstructure knowledge
- Experience with order book reconstruction
- Experience with SIMD, vectorization, or cache optimization
- Experience with columnar data formats
- Familiarity with Python bindings (pybind11)
- Experience with ClickHouse or high-throughput data pipelines
- Background in quantitative trading environments

🧪 What Success Looks Like (First 6 Months)

- Backtest throughput improved materially
- Deterministic, reproducible simulation under heavy load
- Reduced memory footprint of core engine
- Realistic fill modeling implemented for crypto venues
- Clean, maintainable, well-profiled core engine

🛠 Tech Stack

- C++17/20
- Linux
- Event-driven architecture
- Python (research layer)
- High-frequency market data
- AWS / on-prem compute

🎯 Who This Is For

You are likely a fit if you:

- Care obsessively about performance
- Think in cache lines, not just classes
- Get uncomfortable when you see unnecessary allocations
- Enjoy profiling more than writing dashboards
- Prefer building engines over web apps