Načítání popisu…
Popis nabídky
Koton
100000 - 180000 Kč
Brno, Česko
We trade the world's most volatile markets and make them more efficient. Koton is a 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.
TL;DR→ Own the platform our trading systems run on: Linux, AWS, our own on-prem infrastructure, networking, databases, deploys and observability.
→ You'd be the first person fully dedicated to infrastructure — but you're not starting from zero or alone. The engineer who built most of it is still here and will hand it over deliberately.
→ Markets run 24/7. There's no maintenance window, and production means live trading with real capital.
→ End-to-end ownership. You get problems and context, not a queue of infrastructure tickets.
→ 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.
Note: This is a senior, hybrid, high-ownership individual-contributor role
What you'd actually be runningCloud: AWS across two regions — Tokyo close to the exchange for latency, Dublin for internal tooling
IaC: Terragrunt + OpenTofu, in-house module library, remote state with locking
Config: Ansible — roles covering ~15 host types, from trading engines to database nodes
CI/CD: Self-hosted GitLab, tag-driven build → registry → deploy pipelines, autoscaled spot runners, custom builder images
Data: TimescaleDB with Patroni HA behind health-checked HAProxy, plus SQL Server
Observability: Prometheus, Loki and Grafana, plus some home-grown alerting that needs consolidation
Network: WireGuard, pfSense driven by API, split-horizon DNS between cloud and on-prem
On-prem: Our own infrastructure running Proxmox, Git and core databases
Workloads: Low-latency .NET services consuming real-time exchange data
No Kubernetes. We run containers directly on hosts with host networking. That's deliberate: extra layers aren't free when you're measuring latency in microseconds.
If your main ambition is to build a Kubernetes platform, this probably isn't the job for you.
What you'll do
Own the platform end to end. Linux, AWS, on-prem, networking, deployment, secrets and access. Infrastructure should be reproducible and understandable — not a collection of machines somebody configured once and hopes nobody reboots.
Make deployments safe in a live market. There's no maintenance window. Production systems are trading real capital while releases happen. One of the early opportunities is improving how releases are versioned, deployed, verified and rolled back so we always know exactly what's running and can confidently return to the previous state.
Build observability that settles arguments. When latency spikes, we want to know quickly whether it was us, the network or the exchange. Structured logging, meaningful metrics, latency histograms and disciplined clock synchronisation should make that answerable in minutes rather than hours.
Run the data layer. PostgreSQL and TimescaleDB handle continuous market-data workloads. You'll own replication, Patroni failover, retention and compression policies, performance and backups that have actually been tested by restoring them.
Own networking that matters commercially. Connectivity and routes to exchange endpoints, IP whitelisting, remote access and failover paths. Latency here isn't an abstract infrastructure metric — it can be the difference between a good fill and a missed opportunity.
Improve the internal platform. Access and identity across our systems is automated from Google Workspace by a Python service provisioning Git, monitoring, VPN and internal tooling. You'll extend it and help us simplify and de-risk identity management.
Handle incidents — and make the next one smaller. Occasionally something exceptional happens outside normal office hours. You'll help resolve it, understand why it happened and improve the system so the same incident doesn't happen twice.
Work directly with developers, researchers and traders. 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.
Our CTO is hands-on and knows the current infrastructure because he helped build it. You'll have someone to challenge ideas with and learn the existing system from, without having someone managing you at arm's length.
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.
Requirements
Deep Linux knowledge. You can work out what a process or machine is actually doing when something goes wrong and know which tools will give you the answer.
Infrastructure as code and containers. Terraform/OpenTofu, Ansible, Docker or close equivalents. You value reproducibility over cleverness.
Real networking knowledge. TCP behaviour, routing, MTU, VPNs, firewalls and DNS. Enough to debug a problem that exists somewhere between two machines — including reaching for a packet capture when necessary.
Observability as a discipline. You know what to measure, how to make it useful and what noisy telemetry to delete.
PostgreSQL operations. Replication, failover, backup and restore, and performance under load.
CI/CD you've owned , not just consumed. You've built pipelines and been responsible for what happens when a release goes wrong.
Useful scripting. Python or Bash written well enough that someone else can safely depend on it, including integrations with APIs.
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 systems and real capital.
Willingness to be occasionally on call when an exceptional incident needs a fast response.
Bonus points
What we won't promise you
You won't inherit a perfectly tidy platform.
Some parts are well designed and mature. Others were built quickly by developers while their main focus was keeping trading systems moving. Documentation isn't complete, and your first months will involve reading, asking questions and deciding what should be improved — and what should simply be left alone.
You will get a real handover. The engineer who built most of the current infrastructure is still here, and transferring ownership deliberately is one of the main reasons this role exists. You're not being dropped into an undocumented system and wished good luck.
Occasionally you'll investigate production incidents outside office hours because crypto markets never sleep. It's not frequent, but it's part of operating systems that trade real capital.
If you're looking for a mature infrastructure organisation with established teams and narrowly defined responsibilities, this isn't it. If you'd rather take a working platform, understand it deeply and make it genuinely yours, it probably is.
Benefits
Terms:
We believe in paying fairly, 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.
How to applyNo cover letter, please. We don't necessary need a CV either.
Instead, write us a few paragraphs about a system you ran or an incident you handled — what broke, how you found it and what you changed so it wouldn't happen again.
That tells us far more.