About Qblox

Qblox is a deep-tech scaleup whose mission is to accelerate the worldwide race towards scalable quantum computers. We do this by providing some of the world's most advanced quantum control stacks to laboratories and quantum startups across the globe.

Our hardware and software sit right next to the quantum chips, giving experimentalists precise control and readout of their qubits. Through our open-source interfaces qblox-scheduler and qblox-instruments, users can write and execute experiments and algorithms using Python – from defining quantum circuits to compiling down to our quantum assembly, Q1ASM.

We offer a dynamic environment where engineering meets cutting-edge physics research.

About the role

You'll join the team building our next-generation scalable cluster platform — a radically redesigned quantum control architecture targeting fault-tolerant quantum computing at industrial scale. At the heart of this system is the Network & Middleware layer: the software that enables ultra-low-latency communication between the host computer, cluster modules, and external HPC infrastructure.

As a Senior Software Engineer, you'll own and deliver critical parts of this network stack, while actively elevating the engineering capabilities of the wider team through mentorship, code reviews, and technical leadership.

This is a hands-on C++ systems-engineering role. Your world lives where high-performance software meets advanced network fabrics — you'll collaborate closely with hardware teams, but we don't expect you to be a bare-metal embedded firmware engineer.

Note: a background in quantum computing or deep tech is a nice to have, but not required.

What you will do

● Design and implement our core network middleware in C++, delivering robust, embeddable libraries that support message routing, streaming, and stateful communication

● Implement and tune high-performance transport protocols — including RDMA, RoCEv2, and classic Ethernet pub/sub — for low-latency, high-throughput data exchange

● Own network performance end-to-end: profile, benchmark, and optimise the stack to meet sub-microsecond round-trip goals for real-time quantum feedback loops

● Develop network layout configurations, routing strategies, and built-in diagnostic tools to ensure cluster health and reliability

● Contribute to architecture decisions around Scalable Messaging Fabric (SMF) network support, contention handling, and deterministic networking

● Partner closely with Platform, Firmware/FPGA, and Applications teams to integrate the middleware into the broader software ecosystem

● Mentor and coach more junior engineers through code reviews, technical guidance, and a culture of continuous learning

Enough about us, what about you?

In order to really enjoy this role, we imagine you will have a background encompassing the following:

Must-haves

● 6+ years of professional software engineering experience with a strong focus on modern C++ (C++17/20), including multi-threading, concurrency models, and memory management

● Deep knowledge of socket programming, transport layer internals, packet processing, and the Linux networking stack

● Hands-on experience with kernel-bypass or low-latency networking architectures (e.g. RDMA, RoCE, DPDK, or eBPF/XDP)

● Proven track record of designing clean, well-documented APIs and embeddable middleware libraries for consumption by other engineering teams

● Strong fundamentals in CI/CD pipelines, automated testing frameworks, version control (Git), and debugging tools (e.g. GDB, Wireshark)

● Experience mentoring developers and advocating for clean code architectures

Nice-to-haves

● Experience with embedded Linux or SoC-based platforms (e.g. Xilinx Zynq UltraScale+)

● Familiarity with hardware/software co-design interfaces (e.g. SystemRDL/PeakRDL or register maps)

● Python experience for automated testing, tooling, or scripting

● Background in real-time systems, HPC, or integration with GPU compute frameworks (e.g. NVIDIA CUDA-Q)

● Exposure to complementary systems languages such as Rust or Go