Kotlin Backend Engineer - Payments & Distributed Systems

At Katanox, we're looking for a Software Engineer to join our team.

About Katanox: Katanox is building the infrastructure layer for hospitality: software that connects hotels and travel buyers and moves money between them. Our platform brings distribution and payments into one workflow (contracting, connectivity, reconciliation, and settlement), so partners can operate with less fragmentation and fewer manual handoffs. For engineers, this means building reliable systems that handle complex B2B workflows and real financial constraints, with a focus on data integrity, auditability, security, and operational excellence. We're headquartered in Amsterdam with hubs in London and New York.

Why join Katanox:

• Build software that moves real money: Work on Kotlin services that sit on the critical path for payments, reconciliation, and settlement.
• Solve hard problems, end-to-end: Own outcomes across data models, APIs, and the production realities (observability, reliability, compliance).
• High-trust team, high standards: Direct communication, strong engineering fundamentals, and a bias toward shipping and learning.
• In-person collaboration (hub model): We do our best work together, spending regular time in Amsterdam, London, or New York to move faster and build trust.
• Growth-stage ownership: The surface area is big, and the team is lean; your decisions will shape the platform.

How We Work: A cornerstone of our culture is in-person collaboration. We follow a "hub" model with unique hubs in Amsterdam, London, and New York, where we regularly collaborate face-to-face, onboard customers and colleagues, hold design sessions, and host events. We do not hire for strictly remote roles. We expect people to spend meaningful time in our hubs because this is how we maintain our culture, build trust, and move quickly together. We're also a financially regulated company. That means high standards for security, auditability, and decision-making. This means your work ships with the rigor and reliability you'd expect from systems that move real money.

Our values:

• Team over the individual, no ego: We prioritize the success of the whole team over individual agendas. We win together, share credit, and leave egos at the door.
• Data beats excitement: We welcome bold ideas, but we commit based on evidence. We use data, experimentation, and clear hypotheses to decide what to build.
• Dare to do: We are proactive, take smart risks, and move from talking to doing. We learn by shipping and improve through iteration.
• See it, own it, and close it: When we spot a problem or opportunity, we take responsibility to drive it to completion instead of assuming someone else will.
• We apply radical candor: We care personally and challenge directly. We give and receive honest feedback so we can grow faster as individuals and as a team.
• In person first, call second: We prioritise in-person collaboration in our hubs to build trust, move quickly, and solve hard problems together.
• Build collaboratively: We actively involve the right people, share context early, and co-create solutions across teams and disciplines.
• Iterate fast and pragmatically: We ship small, learn quickly, and avoid over-engineering. We focus on solutions that work in reality, not just in theory.

About The Role: You'll work on the backend systems at the core of Katanox. These are the services that move money between hotels, travel buyers, and payment networks, and the infrastructure that keeps bookings, pricing, and reconciliation consistent across a fragmented industry. Expect to ship Kotlin services that handle real transactions, in real time, for real customers. This role is for someone who likes ownership and depth. You'll help shape architecture with other engineers, ship iteratively, and raise the bar for reliability and correctness in a regulated environment where a missed event is a failed reservation or a misrouted payout.

What You Will Work On:

• Building distributed systems that move real money and real bookings between hotels, the world's largest travel agents, and payment networks, where a dropped event isn't a bug ticket, it's a failed reservation or a misrouted payout.
• Designing and operating high-availability components in a regulated environment, where "it usually works" isn't good enough. Think idempotency, exactly-once semantics, graceful degradation, and the kind of observability that lets you sleep at night.
• Working on the parts of the platform where scale is non-trivial: millions of searches per day, connectivity to a long tail of supplier and acquirer systems, and pricing/availability flows that have to stay correct under load.
• Going deep on a single domain (payments, distribution, contracting, reconciliation) while still understanding how the whole platform fits together, because the interesting problems at Katanox usually sit at the seams between two of them.
• Shaping architecture decisions, not just implementing them. We're still early enough that the choices you make this quarter will be load-bearing for years to come.
• Owning what you ship end-to-end: design, build, deploy, monitor, and improve. No throw-it-over-the-wall culture.

What We Are Looking For:

• You've built and operated production systems that mattered. Ideally distributed, ideally with real availability and consistency requirements.
• You know the difference between "passes the tests" and "behaves well at 3 a.m. on a Sunday."
• Strong Kotlin or Java experience, and you're opinionated about why.
• You care about code that's simple, testable, and boring in the best way.
• You enjoy reasoning about hard problems like concurrency, failure modes, data consistency, system boundaries and you can turn ambiguous business requirements into something that actually works.
• You want to work with smart, low-ego people who push you. We hire for genuine curiosity and craft, not credentials, and we expect you to make the people around you better.
• You're genuinely interested in the domain. Payments and travel distribution are messy, regulated, and full of edge cases. If that sounds tedious rather than interesting, this probably isn't the right role.
• You take ownership. When something is broken or unclear, you pick it up rather than file it under "someone else's problem."
• Solid fundamentals: data structures, algorithms, system design, testing.
• Fluent in English.

Tech stack snapshot:

• Backend: Kotlin, Ktor, Arrow-kt, Jooq, Postgres
• Frontend: React
• Infra: AWS, K8S

Apply for the job: Do you want to join our team as our new Software Engineer? Then we'd love to hear about you!