C++ Software Engineer (High Frequency Trading)

Our client, a firm where O(n) is considered a catastrophic failure, is looking for L4/L5 C++ Engineers for their Core Trading Technology team. This is a role for developers who believe the OS is just a bootloader for their application and that true performance begins where the kernel ends.

The Role

You'll be hands-on, optimizing core trading infrastructure until it's little more than a thin, beautiful layer on top of the silicon. Your goal is to build high-performance, scalable systems with a religious devotion to ultra-low latency and deterministic performance. You'll be interacting with Central Limit Order Books (CLOBs), which are basically the final boss of concurrent, high-throughput data structures.

Key Responsibilities: What You'll Actually Be Doing

• Architecting in C++: You will design and implement trading systems using modern C++. We expect you to have strong opinions on C++20/23 features and to write code so efficient it makes compilers weep with joy.
• Applying Mechanical Sympathy: You don't just write code; you feel the hardware's pain. You'll be expected to arrange memory layouts for cache-line perfection, manually vectorize with SIMD, and generally treat the CPU as a cherished (and highly predictable) friend.
• Wrestling with Concurrency: Go head-to-head with the gnarliest concurrency demons. You’ll implement lock-free queues, wield memory barriers like a pro, and hunt down and eliminate false sharing with extreme prejudice.
• Achieving Kernel Bypass: You will build systems for Market Data and Direct Market Access (DMA) that treat the OS kernel as a slow, unnecessary middleman. Why make a system call when you can mmap the hardware's registers directly?
• Mastering Time Itself: Ensure nanosecond precision with heroic time-synchronization efforts.
• Embracing the Profiler: Live by the "Measure Everything" philosophy. You should be more comfortable in perf, or your own custom profiler than in your IDE. TDD is a given.

Qualifications:

• Education: A Bachelor's degree in Computer Science or equivalent proof that you have achieved enlightenment through the study of algorithms.
• C++ Mastery: You must be fluent in C++. You can explain SFINAE, the Rule of Zero, and why volatile doesn't solve threading problems. You find memory leaks for fun.
• CS Fundamentals: A deep, intuitive understanding of data structures, OS internals, and computer architecture. You know why a pointer-chasing linked list is a crime against CPU caches.
• Performance Tuning: Solid, practical experience making slow code fast.
• Networking Knowledge: Familiarity with network programming, low-level system calls, and kernel-level interactions is essential.
• HFT Experience: Preferred, but not required. A background in game engine development, embedded systems, or any field where nanoseconds matter will be highly valued.

The Mindset: How We git commit

The philosophy is built on Software Craftsmanship: Modular Design, Clean Code, High Cohesion, and Low Coupling. The KISS Principle stands for "Keep It Stupidly Speedy." If the thought of non-deterministic performance gives you anxiety, you'll fit right in.