Software Engineer
Software Engineer on Bloomberg's Core Communications Distribution team in London, working on real-time messaging infrastructure. I designed and built a C++23 service that replaces hard-coded event-routing logic with a configurable, thoroughly tested rule engine, focused on low latency and correctness.
- ▸Designed and built a C++23 service from scratch on Bloomberg's real-time messaging infrastructure
- ▸Replaced a manual, code-driven process with a configurable, composable rule engine, so routine changes no longer require code changes
- ▸Focused on low, predictable latency on the real-time hot path and on correctness under production load
- ▸Covered by unit, integration, and performance tests, and validated against historical production data before rollout
- ▸Owned the architecture and implementation end to end
Context
Bloomberg's messaging infrastructure moves events between services in real time, where both latency and reliability matter. I joined the Core Communications Distribution team in London for a six-month full-time placement, working on the systems that decide how those events are filtered and routed.
Originally, the logic for deciding which events to forward lived in hard-coded application code. Adjusting it meant a manual, code-driven process for what was really a configuration change.
What I Built
I designed and built a new service in C++23, from the ground up, that treats those decisions as data instead of code. Rules are expressed in a composable, configurable form and evaluated by a single engine, so routine changes can be made without touching application code.
The two hard constraints were latency and correctness. The service sits on the real-time hot path, so it is built for low, predictable latency and for keeping up under production load, and the performance tests are written against tail latency rather than averages. Because it changes behavior that already exists, I treated correctness as something to demonstrate rather than assume: it is covered by unit, integration, and performance tests, and validated against historical production data before being put forward for rollout.
What I Owned
I owned the architecture and the implementation: the rule model, the evaluation engine, the messaging integration, and the tests around them. The clearest lesson so far has been writing systems code that has to be both fast and provably correct, on infrastructure where regressions are costly and hard to reverse.