Senior C++ Engineer – Low-Latency Trading Systems - HFT

Kalpa Group; New York (NY); On-site; USD 200,000 - 300,000; Full time

Job summary

Kalpa Group in New York seeks a senior C++ systems engineer to own end-to-end HFT execution paths, from order routing to market data and latency tooling. You will design lock-free components, implement kernel bypass networking, and optimize for sub-microsecond paths in Linux.

Operate in a zero-bloat stack with close collaboration to quants and traders; leverage C++20/23, FIX/ITCH interfaces, and high-throughput IPC.

Qualifications

• Experience building latency-sensitive C++ software in Linux environments.
• Strong systems engineering judgment for high-performance execution software.
• Ability to own end-to-end architectural components in a zero-legacy stack.

Responsibilities

• Design and implement lock-free order routing and venue adapters from scratch.
• Architect high-throughput, zero-copy market data pipelines with deterministic latency.
• Collaborate with quant researchers to bring intraday models to live markets.
• Build real-time latency profiling tools and kernel-bypass optimizations.

Skills

C++20/23

HFT experience

Lock-free design

Kernel bypass

Tools

FIX protocol

ITCH/OUCH

Job description

Modern C++ (20/23), High-Frequency Trading (HFT), Kernel Bypass, Lock-Free Architecture

$200,000 – $300,000 Base Salary + Performance Bonus + Benefits (Circa $1M+ Total Comp)

Open to guaranteed first-year bonus structures, sign-on buyouts, and non-compete coverage for exceptional talent.

High-frequency execution in 10-year-old monolithic codebases is exhausting.

At many Tier-1 HFT prop shops and giant multi-managers, 80% of a senior engineer's day is spent navigating C++03 tech debt, fighting template bloat, waiting on risk committees, or building tools three layers removed from live trade execution.

We are partnering with a fast-growing buy-side quantitative trading group rebuilding their core HFT execution, market data, and order-routing architecture across US equities, options, and futures.

This is a clean-slate platform build: zero legacy code debt, zero release-management bureaucracy, and direct, daily proximity to quant research and live desk execution.

We are looking for senior C++ systems engineers who want complete end-to-end architectural ownership of the tick-to-trade path rather than managing a tiny, isolated slice of an engine.

What You’ll Build & Own:

• Sub-Microsecond Order Routing: Design and implement lock-free HFT order entry, exchange connectivity (FIX, ITCH/OUCH, binary formats), and venue adapters from scratch using C++20/23.
• Zero-Allocation Market Data: Architect high-throughput, zero-copy tick pipelines engineered to handle extreme volatility spikes without dropping packets or spiking tail latency.
• Deterministic Strategy Pipeline: Work side-by-side with quant researchers to bring intraday alpha models into live markets with zero-copy IPC and deterministic execution times.
• Low-Level Hardware Acceleration: Eliminate OS overhead via kernel bypass (Solarflare / OpenOnload / onload sockets), CPU cache optimization, memory layout tuning, and NUMA-aware thread pinning.
• Real-Time Latency Profiling: Build custom micro-benchmarking and hardware counter tooling to trace and profile execution path latency down to the nanosecond.

The Stack & Environment:

Modern C++ (17/20/23) running on bare-metal, heavily tuned Linux kernels. Custom lock-free ring buffers, shared memory IPC, and kernel bypass networking sit at the absolute core of the high-frequency execution path.

While C++ handles the hot execution path, Python and Rust are used across off-path research tooling, simulation, and platform pipelines.

Experience with FPGA co-design, venue launch expansion, or custom hardware acceleration is a plus, but not required. What matters is strong systems-level engineering judgment and the ability to build reliable, high-performance execution software without overengineering.

You’ll Enjoy This Role If You:

• Have deep, hands-on experience building production-critical, latency-sensitive C++ software on Linux within HFT or electronic trading environments.
• Care deeply about the mechanical sympathy of your code: CPU caches, memory layout, lock-free concurrency, and hardware limits.
• Have exposure to venue protocols, binary market data, network sockets, or Solarflare/onload drivers.
• Prefer shipping high-impact, clean execution code to live markets over sitting in architecture committee meetings.
• Want transparent, direct alignment with desk performance, PnL, and platform speed.