Build a Distributed Shared Memory Layer Over RDMA for Risk Engines
Overview
What this challenge is about.
Build a distributed shared memory library in C++ using RDMA, then replay a market-state trace. Earn your verifiable certificate.
The scenario
Proprietary trading firms run independent risk engines that must agree on a fast-moving picture of prices and positions; today they synchronize that picture by sending explicit network messages, which adds latency and code complexity on every market-state update.
The Brief
What you'll do, and what you'll demonstrate.
Can risk engines on separate machines share a single consistent view of live market state by reading each other's memory directly over the network, fast enough and correctly enough to trust in production?
Earning criteria — what you'll demonstrate
- Design and implement a directory-based sequential consistency protocol over one-sided remote memory operations
- Use Remote Direct Memory Access verbs (one-sided read/write and atomics) correctly while avoiding unnecessary two-sided round-trips
- Reason about and demonstrate correctness of a shared-memory protocol under concurrent writers
- Benchmark a distributed system rigorously, reporting tail latency and overhead rather than averages alone
- Translate measured system behavior into an honest, decision-ready production recommendation
Program Fit
Where this fits in your program.
Sharpens the same skills your degree expects you to demonstrate.
Aligned coursework coming soon.
Skills
Skills you'll demonstrate.
Each one shows up on your verified credential.
- Distributed Systems
Apply distributed systems to solve real industry problems and demonstrate production-level capability.
- Rdma
Apply rdma to solve real industry problems and demonstrate production-level capability.
- Consistency Models
Apply consistency models to solve real industry problems and demonstrate production-level capability.
- C Plus Plus
Apply c plus plus to solve real industry problems and demonstrate production-level capability.
- Benchmarking
Apply benchmarking to solve real industry problems and demonstrate production-level capability.
- Operating Systems
Apply operating systems to solve real industry problems and demonstrate production-level capability.
Careers
Career paths this challenge builds toward
Completing this challenge demonstrates skills that transfer directly to these roles:
Distributed Systems Engineer
Building a consistency protocol over remote memory and proving it under concurrent writers mirrors the core work of engineering low-latency distributed infrastructure, where correctness under contention and disciplined measurement decide what ships.
This challenge sharpens
- distributed-systems
- consistency-models
- benchmarking
Low-Latency Systems Architect
Designing a Remote Direct Memory Access data path and choosing one-sided operations over messaging is exactly how architects in trading and high-performance computing shave microseconds while keeping shared state coherent across machines.
This challenge sharpens
- rdma
- distributed-systems
- operating-systems
High-Performance Computing Engineer
Implementing shared memory over RDMA in C++ and benchmarking it across node counts maps directly to HPC roles where engineers tune memory access, interconnects, and consistency for tightly coupled clusters.
This challenge sharpens
- c-plus-plus
- rdma
- benchmarking