Founding Member of Technical Staff (MTS)Quantitative Developer — C++ | Ultra-Low-Latency Exchange Connectivity | HFTLocation: Hyderabad, India — On-site

Type: Full-Time

Reports To: Founder & CPTO

About Neural DerivativesNeural Derivatives is a quantitative research and technology company building physics-first intelligence for markets, AI infrastructure, energy, and compute-driven economies.

We combine quantitative research, market microstructure, artificial intelligence, high-performance computing, and systems engineering to build proprietary trading systems and next-generation financial infrastructure.

Our immediate focus includes systematic trading, electronic markets, equities, derivatives, commodities, and digital assets, supported by proprietary research, alternative data, and high-performance execution infrastructure.

We are building the technology stack from first principles, with research, engineering, and trading tightly integrated.

The MissionBuild a quantitative trading platform where research, technology, and execution operate as one system:

Market Data → Research → Simulation → Signal → Risk → Execution → Exchange → P&L;

We believe exceptional trading infrastructure is a competitive advantage.

The RoleWe are looking for a Founding Member of Technical Staff (MTS) — Quantitative Developer to design and build the core low-latency trading and exchange connectivity infrastructure of Neural Derivatives.

This is a founding engineering position. You will work directly with the Founder & CPTO and closely with quantitative researchers to build systems that connect proprietary strategies to live markets.

The role sits at the intersection of:

C++ • Systems Engineering • Market Microstructure • Exchange Connectivity • Quantitative Research • High-Performance Computing • HFT

You will not simply maintain an existing platform. You will help architect and build the platform itself.

What You Will BuildExchange Connectivity

- Direct, production-grade connectivity to electronic trading venues.
- Exchange-native market-data and order-entry protocols.
- FIX where appropriate.
- TCP/UDP and multicast networking.
- Session management, sequencing, recovery, retransmission, and failover.
- Exchange-specific connectivity and certification.

Market Data EngineDesign infrastructure for receiving, decoding, processing, normalizing, recording, and distributing real-time market data.

Work with

- L1/L2/L3 and tick-level data
- Order-book events
- Trades and executions
- Multi-venue feeds
- High-message-rate streams

Systems must provide low latency, determinism, correctness, and sustained throughput. Order & Execution InfrastructureDesign and implement the execution path:

Signal → Risk → Order → Exchange → Acknowledgement → Fill → Position

Build components covering

- OMS/EMS
- Order routing
- Order state machines
- Pre-trade risk
- Execution handling
- Cancel/replace
- Position tracking
- Trade reconciliation

Quantitative Strategy RuntimeWork with quantitative researchers to productionize strategies and bridge: Research → Simulation → Production C++ → Live Trading

Ensure production execution preserves the correctness and performance assumptions of research.

Simulation & BacktestingBuild infrastructure for:

- Tick-level replay
- Historical market-data reconstruction
- Order-book simulation




- Execution simulation
- Strategy backtesting
- Deterministic replay
- Research-to-production validation

Performance EngineeringLatency is a first-class engineering requirement. You will optimize the complete path:

NIC → Network → Kernel/User Space → Market Data → Strategy → Risk → Order Gateway → NIC → Exchange

This includes CPU architecture, cache locality, memory allocation, NUMA, CPU affinity, scheduling, lock contention, atomics, memory ordering, branch prediction, serialization, networking, system calls, interrupts, kernel configuration, and NIC configuration.

We care about measured performance—not theoretical performance.

Key Responsibilities

- Design and develop ultra-low-latency trading systems using modern C++17/20.
- Architect exchange connectivity, market-data, OMS/EMS, risk, and execution components.
- Build deterministic, high-throughput systems for live electronic trading.
- Develop high-performance market-data handlers and native exchange gateways.
- Integrate quantitative strategies into production systems.
- Build tick-level recording, replay, simulation, and backtesting infrastructure.
- Profile and optimize systems across application, OS, network, and hardware layers.
- Design recovery, fault isolation, and failure-handling mechanisms.
- Develop production monitoring and trading-system observability.
- Work directly with researchers to identify execution bottlenecks and improve trading performance.
- Participate in exchange certification, production deployment, and live-system operations.
- Establish engineering standards for performance, correctness, testing, and reliability.

Required Technical SkillsC++Strong production expertise in C++17/20, including:

- Advanced STL and templates
- RAII and memory management
- Move semantics
- Concurrency and multithreading
- Atomics and memory ordering
- Lock-free / wait-free programming
- Custom allocators and object pools
- Cache-aware programming
- Performance profiling and optimization
- Low-level debugging

We are looking for engineers who understand not only how to write C++, but what the machine actually does when that C++ executes. Systems & LinuxStrong understanding of:

- Linux internals
- Processes and threads
- Virtual memory
- CPU scheduling
- Context switching
- Interrupts and system calls
- CPU caches and cache coherency
- NUMA and memory hierarchy

NetworkingStrong understanding of:
- TCP/IP
- UDP
- Multicast
- Socket programming
- Packet processing
- Network buffers
- Network performance and tuning

Trading & Market MicrostructureStrong understanding or demonstrated interest in:
- Order books
- Market data
- Order lifecycle
- Matching engines
- Market microstructure
- Execution
- Order types
- Pre-trade risk
- Exchange behavior

Preferred ExperienceExperience with one or more of the following is highly valuable:
- NSE / BSE / MCX
- CME / ICE / Eurex / Nasdaq / NYSE / Cboe
- HFT or proprietary trading
- Direct market access




- Exchange infrastructure
- Kernel bypass / DPDK
- Solarflare / Xilinx / SmartNICs
- RDMA
- FPGA-based trading systems
- FPGA/software co-design
- PTP / IEEE 1588
- Hardware timestamping
- NIC offload
- NUMA-aware systems
- Lock-free data structures
- SBE / ITCH / OUCH or comparable protocols
- Tick-level simulation
- Order-book reconstruction
- Market replay
- High-performance serialization

FPGA experience is not mandatory, but understanding hardware acceleration and software/hardware boundaries is a significant advantage. Candidate ProfileWe are looking for an engineer who is systems-first, performance-driven, quantitatively curious, and highly autonomous.

You should

- Think deeply about performance, correctness, and failure modes.
- Be comfortable working below application-level abstractions.
- Understand what happens between a packet arriving at a NIC and an order leaving the machine.
- Prefer measurement and benchmarking over assumptions.
- Have strong debugging and problem-solving instincts.
- Be comfortable owning systems from architecture through production.
- Work effectively with quantitative researchers.
- Make pragmatic engineering trade-offs.
- Have a strong bias toward simple, deterministic, production-grade systems.
- Be comfortable operating with significant technical ambiguity and ownership.

You do not need to have worked at a major HFT firm. Exceptional engineers from exchanges, banks, electronic trading firms, networking, HPC, operating systems, distributed systems, or other latency-sensitive environments are encouraged to apply. Why This Is a Founding RoleYou will be among the foundational technical members of Neural Derivatives.

You will have the prospect to:

- Build the trading infrastructure from zero.
- Define the architecture of the execution platform.
- Work directly with the Founder & CPTO.
- Work alongside quantitative researchers.
- Own systems that directly influence live trading performance.
- Make decisions across software, operating systems, networking, and hardware.
- Establish engineering standards for future teams.
- Grow into ownership of major components of the firm's trading technology.

There is no large legacy platform to inherit. You will help decide what gets built, how it gets built, and how it performs in production.

Why Join Neural Derivatives

- Build from first principles: Build a trading platform from the ground up.
- Direct technical ownership: Your decisions directly influence production systems.
- Research integration: Work closely with quantitative researchers.
- Deep systems exposure: C++, Linux, networking, exchange protocols, market microstructure, and performance engineering.
- Founding-team impact: Become one of the foundational technical members of a quantitative technology company.

Our Engineering PhilosophyMeasure. Simplify. Optimize. Validate. Deploy.

We value technical depth, first-principles thinking, performance discipline, engineering rigor, research collaboration, system ownership, reliability, and intellectual honesty.

At Neural Derivatives, research becomes software, software becomes execution, and execution becomes a trading business.

If you want to build the infrastructure rather than inherit it, we want to hear from you.

Neural Derivatives

Physics-First Intelligence for AI Compute, Energy & Markets

📌 Founding Member of Technical Staff (MTS) – Quantitative Developer — C++ | Ultra-Low-Latency Exchange Connectivity | HFT (Hyderabad)
🏢 Neural Derivatives Research
📍 Hyderabad