Overview
What this challenge is about.
Diagnose Heap Corruption in a Trading Firm's Order Gateway. Expert-level challenge in code. Writing production code that solves real engineering problems, ea...
The Brief
What you'll do, and what you'll demonstrate.
Determine, from the case file alone, what is corrupting the order gateway's heap and how to fix it without breaking the gateway's 18-microsecond median latency budget.
This is not a coding exercise. It is the work a software engineer does between a Jira ticket and a merged PR. That distinction matters to every hiring manager who has seen candidates solve LeetCode problems and none who have shipped production code under real constraints.
When you finish, you will have something most graduates do not: a real-world deliverable, verified by Ewance, that you can show to a hiring manager and say "I did this. Here is the proof."
Earning criteria — what you'll demonstrate
- Reason from crash evidence (call stacks and damaged heap structures) back to a specific source-code defect without guessing.
- Use AddressSanitizer and ThreadSanitizer to turn an intermittent, load-dependent crash into a deterministic, repeatable test.
- Distinguish the candidate failure modes of a manual memory pool — use-after-free, double-free under a data race, and buffer overrun — and gather evidence for one over the others.
- Design a memory-safety fix that respects a strict latency budget by avoiding new allocations on the hot path.
- Benchmark a low-latency change and report median and tail latency credibly against a recorded workload.
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.
- Cpp Programming
Apply cpp programming to solve real industry problems and demonstrate production-level capability.
- Manual Memory Management
Apply manual memory management to solve real industry problems and demonstrate production-level capability.
- Pointers
Apply pointers to solve real industry problems and demonstrate production-level capability.
- Memory Debugging
Apply memory debugging to solve real industry problems and demonstrate production-level capability.
- Performance Benchmarking
Apply performance benchmarking to solve real industry problems and demonstrate production-level capability.
- Concurrency
Apply concurrency 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:
Low-Latency Systems Engineer
Firms that build trading and other real-time systems need engineers who can debug memory corruption in custom allocators without slowing the hot path. This challenge mirrors that work end to end: evidence-driven diagnosis, a deterministic reproducer, and a fix held to a microsecond-level budget.
This challenge sharpens
- cpp-programming
- manual-memory-management
- memory-debugging
Trading Infrastructure Engineer
Trading-infrastructure teams own the gateways between strategy and exchange, where a heap bug can halt a desk. The challenge builds the exact reflex they hire for: isolating a race-driven corruption under load and shipping a fix that survives a strict latency review.
This challenge sharpens
- concurrency
- pointers
- performance-benchmarking
C++ Performance Engineer
Performance engineers are judged on changes that are both correct and fast. Here you practice fixing a memory-safety defect while proving with before-and-after benchmarks that median and tail latency stay inside budget — the dual mandate these roles live by.
This challenge sharpens
- cpp-programming
- performance-benchmarking
- manual-memory-management