We trade the world's most volatile markets and make them more efficient.

Koton is a boutique, proprietary trading firm and a top-tier market maker on the world's largest crypto exchange. Our core is high-frequency market making, where the speed and cost-efficiency of execution decide the outcome.

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. 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.

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. 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.

Requirements

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.

Benefits

Paid time off to actually switch off
Fully catered office : all-day snacks, daily lunch, coffee and drinks on us
Work-from-home flexibility
Training and development to keep sharpening your edge
Performance bonuses tied to results
Relocation support for candidates moving to Czechia
Pick your own hardware , top-spec kit, no IT-catalogue limits

Annual salary: This depends on your experience, the level of ownership you take on, and other factors. We believe in paying fairly, with a base salary typically ranging from 60,000 to 110,000 EUR per year, and we're always open to a conversation. We like to work with smart people and want them to feel appreciated and to enjoy the work they do here.

Backend Developer (C++/C#) - High-performance trading systems

Začněte e-mailem