Quantitative Developer

Albert Bow Limited; Chicago (IL); On-site; USD 180,000 - 240,000; Full time

Job summary

Albert Bow Limited in Chicago is seeking a Senior Quantitative Developer to convert traders' and researchers' models into fast, robust production systems. You will own the architecture and steer engineering decisions where theory meets hardware, delivering scalable, low-latency solutions.

This hands-on role focuses on writing correct, high-performance software that runs under load, with full lifecycle ownership from development to deployment and testing.

Qualifications

• Experience building high-throughput, concurrent C++ systems.
• Strong understanding of synchronization and interprocess communication.
• Experience with numerical methods and performance tuning.

Responsibilities

• Model implementation: translate pricing and risk models into production systems.
• Concurrency design: architect multicore systems with shared-state concurrency.
• Performance optimisation: improve throughput and latency of numerical code.
• Full lifecycle ownership: build, deploy, test and integrate systems.

Skills

Multithreaded C++

Linux

Low-latency design

Synchronization primitives

Numerical methods

Matrix decompositions

Derivatives pricing

Modern C++

Job description

Senior Quantitative Developer | Competitive Salary | Modern C++ & Low-Latency Concurrency | Chicago

Albert Bow have partnered with a proprietary trading firm that builds and trades its own high-speed strategies in derivatives. Their edge is in the engineering: turning quantitative models into production systems fast enough to trade on. This is a firm where the code is the business.

The Role

As a Senior Quantitative Developer, you'll take the models built by their traders and quantitative researchers and turn them into fast, robust, concurrent production systems that feed their trading algorithms. You'll sit side by side with the desk, own the architecture, and make the engineering calls where theory meets real hardware. This is a hands-on build role, hired first for your ability to write software that runs correctly and runs fast under load.

Key Responsibilities

• Model implementation: Take pricing and risk models from traders and researchers and build fast, robust, concurrent, production-grade versions
• Concurrency design: Architect multicore systems with real shared-state concurrency and efficient synchronisation
• Performance optimisation: Squeeze throughput and latency out of numerical code through cache-aware data layout, memory reuse, and pragmatic speed versus precision trade-offs
• Full lifecycle ownership: Build, deploy, test and integrate your own systems

What You Bring

• Deep, demonstrable experience in multithreaded and concurrent C++ on Linux, with correct designs at high throughput and low latency
• Strong command of synchronisation and interprocess communication primitives and when to use each
• A proven track record optimising numerical calculations for throughput and latency
• Strong modern C++ and practical mastery of the build and deploy loop
• Experience implementing numerical methods and matrix decompositions
• Enough derivatives pricing knowledge to collaborate closely with the desk
• Someone pragmatic about resources who builds systems that run within real core and memory budgets