Full Stack Engineer (Kotlin / JVM)

Bourn; Greater London; On-site; GBP 85,000 - 110,000; Full time

Job summary

Bourn is seeking a Kotlin/JVM backend engineer who thrives on ownership, fast iteration, and solving complex distributed systems problems. You’ll primarily own the backend, designing services that are correct under concurrency and can scale in production.

The role offers the chance to influence the whole feature from API to UI. You’ll design and build Kotlin/Micronaut microservices for lending, payments, receipts and billing, while embracing asynchronous patterns with Kafka/Avro and strong data

Qualifications

• Design and build Kotlin/Micronaut microservices for lending, payments, receipts, billing and accounts.
• Work with asynchronous systems using Kafka and Avro, focusing on correctness under concurrency.
• Collaborate across frontend and backend (Next.js/React) to ship features end-to-end.

Responsibilities

• Design and build Kotlin/Micronaut microservices handling lending, payments, receipts, billing and account management.
• Build asynchronous systems with Kafka and Avro, reason about concurrency and idempotency.
• Collaborate on payments, account infrastructure, and financial data integrations.
• Incorporate authentication, signatures, certificates, key management and webhooks.

Skills

Kotlin

Java

Distributed systems

Concurrency

Tools

Kafka

Avro

Micronaut

Kubernetes

Azure

SWR

Next.js

React

Tailwind

Job description

Kotlin / JVM leaning, full stack and product-minded.

The role

We're looking for an engineer who wants ownership, a fast-moving environment and interesting problems to solve. If you enjoy Kotlin, distributed systems and designing services that have to be correct under concurrency, you'll find plenty to get stuck into. Your centre of gravity will be the backend, with the freedom to own the entire feature.

What you'll be working on

Design and build Kotlin/Micronaut microservices handling lending, payments, receipts, billing and account management. Build asynchronous systems with Kafka and Avro, reason about concurrency and idempotency, and design resilient integrations that behave well under real production conditions.

Work with Tier 1 banks, fintechs and specialist providers on payments, account infrastructure, financial data and transaction monitoring. Some integrations are standard APIs; others are boutique, bank-specific projects that make you unexpectedly knowledgeable about a particular corner of banking.

Get into the engineering behind those integrations: authentication, signatures, certificates, key management, webhooks, network controls and recovery when a provider behaves unexpectedly.

Work with LLMs, agents and MCP clients and servers. Design secure ways for AI systems to interact with financial capabilities, and connect financial data, lending rules and AI-driven decisioning to deterministic production services.

The problems are interesting

A payment arrives twice. Two consumers race to make the same decision. A bank accepts an instruction but the callback arrives late. A workflow crosses several services and then fails halfway through. You'll have the ownership to understand those problems and design solutions.

You'll still work across the stack: build a Next.js/React workflow, expose an API, wire it into SWR and ship the UI in Tailwind/Catalyst. When the problem reaches Azure, Kubernetes or CI/CD, you'll be comfortable following it there.

How we work

We're a small engineering organisation with real autonomy and short feedback loops. Work directly with product, finance and commercial stakeholders. Take a problem, challenge assumptions, make technical decisions and get the solution into production. Use AI extensively, with clear engineering judgement and responsibility for the result.

What matters most

We'd rather find a strong Kotlin/JVM engineer who's curious, autonomous and capable of moving across the stack. Solid Java experience and an appetite for Kotlin are welcome.

You'd enjoy this role if...

• You like owning a problem and shipping useful software.
• You can move across services, UI, data and infrastructure.
• You use AI thoughtfully to increase what you can accomplish.
• You enjoy APIs, distributed systems and unfamiliar integrations.
• You care about production behaviour, including failure and recovery.
• You want tangible outcomes: businesses receiving funding, money moving and lending decisions becoming working products.

Bring your curiosity. Build things that matter.

Interview Process

• Introductory call - a video or phone call with our VP Engineering to get to know each other
• Technical interview - a coding challenge with a member of the engineering team
• Values and ways of working - a conversation with our Chief of Staff
• Founder call - a chat with our founder about Bourn's vision and where we're heading
• Offer - if it's a match, we'll make you an offer