Backend Developer (C++/C#) — high-performance trading systems, Brno

📍 Brno | 🧩 Trading & krypto | 💼 Full-time, primary on-site

TL;DR

• Proprietary trading firm in Brno. We trade our own capital on crypto markets — no clients, no investor reports.

• Design and build high-performance trading systems in C# and C++.

• Help evolve the performance-critical core while building new systems and features.

• End-to-end ownership — design, build, deploy, run.

• 120 000–220 000 CZK · Brno, hybrid (at least 3 days in the office).

• To apply: send us a few paragraphs about a performance problem you solved. No CV or cover letter required.

We build software that trades real capital in live crypto markets. Every microsecond, every allocation and every design decision has a measurable impact on PnL. Engineering isn't supporting the business here — it is the business.

We're a proprietary trading firm based in Brno. We run market making on Binance with our own capital and we're preparing to expand to additional exchanges. No clients. No investor reports. When the system performs well, we make more money. When it doesn't, we lose our own. That creates a very different engineering environment from most software companies.

Most of the codebase is .NET today. Parts of the performance-critical core are moving to C++, while the business continues to evolve with new trading features, infrastructure and exchange integrations. You'll work across both worlds — improving today's production systems while helping shape tomorrow's architecture. You'll own meaningful parts of the system from day one.

Why people enjoy working here

• Real impact. Every optimisation and every new idea shows up in production and ultimately in PnL.

• Small team. Researchers, developers and traders work side by side. There are no organisational walls.

• Ownership. You own systems, not Jira tickets.

• Fast execution. Good ideas often reach production within days.

• Pragmatism. We care about working solutions, not unnecessary process.

• Learning. We openly share knowledge, debate ideas and learn from one another.

• Purpose. Through our Zero+ (kladnenuly.cz) foundation we support projects with positive social impact.

What you'll do

Design and build the high-performance services behind our trading systems while improving existing production software and gradually moving performance-critical components from C# to C++.

Work on performance where it genuinely matters — allocations, latency, throughput, memory layout and cache behaviour. Not micro-optimisation for its own sake: a bad fill and a missed opportunity are the units we measure in.

Integrate with exchanges. HTTP, WebSockets and FIX, including binary protocols. Real-time market data, order flow, account and user data streams. Exchange documentation lies, sequences go out of order and streams drop — the system either stays consistent or fails fast and loudly.

Chase the hard class of bugs. Race conditions, lifetime and use-after-free issues, memory corruption and the things that only appear under production load. This is a real part of the job, not a footnote.

Run what you build. Deploy and operate on Linux (AWS), keep it observable with structured logging and metrics, and handle incidents. Crypto markets run 24/7 and deploys go into a live market with a real position. We don't have an ops team to clean up behind you, which is exactly why nobody here ships something they don't understand.

Work directly with researchers and traders on implementing new strategies and improving the system. You get a problem and context, not a written-up ticket.

What ownership actually means here

We say ownership because it's the main thing we're offering.

• You get problems, not specifications. We expect engineering judgement rather than following predefined designs.

• You own systems, not tasks. Within a few months you'll be the person who understands a part of the core better than anyone else.

• You build it, deploy it and support it. There are no product managers translating requirements or separate ops teams taking over after release.

• Your results are visible immediately. Latency, reliability and PnL settle arguments much faster than presentations ever could.

Ownership also means freedom comes with responsibility. Nobody micromanages you, but nobody automatically picks things up if you drop them either. This role suits people who'd rather be trusted than managed.

What you should have

• Strong C++ with demonstrable performance-sensitive work. You're comfortable reasoning about memory layout, ownership and lifetimes, and what the compiler actually emits.

• Strong C#, particularly the performance-sensitive side. GC behaviour, allocation-free code, async/await, BenchmarkDotNet or dotTrace. Most of the system still lives here, and understanding it is essential before improving or migrating it.

• A solid grasp of concurrency — multithreading, thread safety, memory ordering, ideally lock-free approaches, and a sense of when lock-free is the right answer and when it's a trap.

• The ability to profile and tune, not guess. perf, sanitizers, benchmarking harnesses. When someone says "this will be faster", we ask how they measured it.

• Confidence on Linux.

• End-to-end ownership. You take a problem, decide how to solve it, build it, ship it and keep it running.

• Diligence and discretion. You'll be working close to trading logic and real capital.

• Willingness to be occasionally on call when an exceptional incident needs a fast response.

Bonus points

• Python for tooling, data work and scripting around the systems, and for working with researchers.

• Understanding of trading mechanics — order books, market data, execution.

• Networking and latency tuning — sockets, TCP behaviour, protocol-level optimisation.

• PostgreSQL or TimescaleDB, and database performance tuning.

• AWS.

You don't need to know trading. Most of us didn't. What you do need is curiosity — you can't write good code for a system whose commercial purpose you don't understand.

What we won't promise you

This isn't a greenfield project. The new C++ core is being built alongside a live system that's still trading and still evolving. A meaningful part of your first year will involve understanding the existing .NET codebase, improving it and gradually moving critical components into C++. Every migration is validated against the live system before it ships.

Occasionally you'll investigate production incidents outside office hours because crypto markets never sleep. It's not frequent, but it's part of building systems that trade real capital.

Who usually thrives here

We're looking for people who naturally take ownership, enjoy understanding how complex systems work and would rather solve difficult problems than follow detailed instructions. If you're curious, pragmatic and motivated by building systems with measurable impact, you'll probably enjoy working here.

Terms

• 120 000–220 000 CZK per month

• Brno, hybrid (at least 3 days in the office)

• EU work authorisation required, relocation possible

How to apply:

No cover letter.

Instead, write us a few paragraphs about a system you worked on that had real performance or reliability requirements — what the bottleneck was, how you found it and what you did about it.

That tells us far more than a CV.