Jump Trading | CppCon

Write the code that trades the world

At Jump Trading, we build the systems that power global markets. These systems depend
on speed, scale, and precision. Our engineers write high-performance C++ code that runs
in production across hundreds of exchanges and handles billions of messages a day.
C++ is core to how we operate; it’s the engine behind what we do.

C++ at Jump: what we’re building

We build systems that need to be fast, predictable, and built to last. That means rethinking
them constantly. The default here is: fix it, improve it, understand it all the way down.

Designing and scaling a high-performance simulation system across both hardware
and software to support multiple asset classes
Developing custom hardware solutions that accelerate key parts of the trading
stack
Expanding and maintaining connectivity between Jump’s internal systems and over
100 global exchanges
Optimizing our research and analytics platform to improve signal generation and
trading performance

Engineers who thrive here

We hire engineers who want to understand the why behind the work. The best engineers
here don’t just optimize code, they seek to understand the full platform, how markets
behave, how our systems interact, and why latency, reliability, and scale matter to the
business.

They collaborate across trading, research, and engineering. They ask big questions and
chase down small bugs. They’re not just technical experts. They’re total systems thinkers,
wanting to understand how everything connects, and how to make it better.

Curiosity > credentials. Performance-obsessed in the best way.

Explore open roles: jumptrading.com/careers
Or just reach out and get in touch: Emily Whalen at ewhalen@jumptrading.com

Meet Barry Revzin, C++ Engineer at Jump

Barry Revzin has been at Jump for over a decade, building and rebuilding critical
infrastructure in C++. He joined after working at another trading firm where, in his words,
the culture had grown complacent. At Jump, he found the opposite.

“There’s a constant push to make everything better,” he says. “No one here is satisfied
with the way things are, and that includes senior leadership. You see Bill and Paul in
the office all the time thinking about where we need to be in two, five, ten years.”

That appetite for continuous improvement shows up in the engineering work itself. Since
Barry joined, the team has re-architected its exchange connectivity platform five or six
times, each one more scalable, more consistent, and more collaborative than the last.
“These aren’t small changes,” he says. “They require a lot of people working
together. But they’ve all gone well, and it’s cool to look back and see how much
better we’ve gotten.”

Jump’s engineering culture, he explains, rewards people who want to go deep and wide.
“You can’t just optimize one piece of code in isolation,” he says. “The people who
thrive here are total systems thinkers. They want to understand how the whole
platform fits together and how to make it better.”

That includes staying modern. While some firms lag behind in tooling or language
standards, Barry says Jump actively adopts what’s useful. “We have teams already
compiling on C++26,” he says. “Not because it’s trendy, but because we use the best
tools for the job.”

And while performance matters, it’s not the only goal. “People think everything in this
industry has to be written in hand-tuned assembly and counted in cycles,” he says.
“But even in latency-sensitive systems, it’s about more than just speed. It has to be
clean, maintainable, and evolvable too. We solve problems at every scale, from
making something as fast as possible to designing for the long haul.”

After 11 years, what keeps him excited?

“It’s the people. You can have conversations about design decisions all day here. It’s
a bottomless pit of interesting problems, and it’s full of smart people who want to
solve them together.”

If you’d like to explore the bottomless pit of interesting problems, please reach out to our
recruiting team below.

Catch Barry on Stage 3 on Monday, September 15^th at 14:00 – 15:00 MDT.

What do Struct-of-Arrays and C++26 Reflection have in common? Barry will explain and
take you on a few detours into broadly useful C++ techniques along the way. Come for the
Reflection, stay for the systems-level insights.