Senior Java Engineer (Core Settlement), RTGS Technology

Location: Leeds

Job Description

This is an opportunity to take a senior engineering role inside one of the UK’s most critical technology environments.

RTGS settles on average £800bn per day and is Critical National Infrastructure. The Core Settlement team owns the software at the heart of that service — including the core settlement engine and the services responsible for transaction processing, settlement behaviour, and financial state across RTGS.

As a Senior Java Engineer in the Core Settlement team, you will design, build, operate, and continuously improve the Java services that underpin RTGS settlement and transaction processing.

This team follows a “you build it, you own it model”. You are responsible not just for delivering software, but for how it performs in production - including diagnosing issues, restoring service, and turning operational learning into engineering improvements.

Flexible Working Options

This role is open to flexible working patterns, which may include:

• Flexible start and end times to each day
• A 50% in-office attendance requirement that can be spread across the month, with flexibility to reflect operational commitments such as on-call and out-of-hours work
Working from abroad (subject to approval)

Opportunities in Leeds:

We’re excited to be growing our presence in Leeds, a city we’ve been connected to for nearly 200 years! Our modern, accessible office in the City Centre offers a supportive, flexible working environment. The majority of roles, including this one, are now available in Leeds, giving you the chance to build a meaningful career outside of London while contributing to our mission from a dynamic and growing location. You’ll work collaboratively with London-based colleagues in a hybrid model, with regular opportunities to travel into the London office to meet and connect together in person.

A day in the role:

Your day might begin with the team stand-up — reviewing priorities, surfacing blockers, and focusing the team on the most important engineering and operational work.

Much of your time will be spent working directly in the core services - designing and implementing changes to the settlement engine, improving transaction processing behaviour, resolving defects, or enhancing resilience and performance in core Java services.

You may be working on the evolution of core settlement capabilities - refining service behaviour, improving correctness, or making changes that improve resilience, operability, and recoverability in production.

At times, you will be investigating production issues - carrying out root cause analysis, restoring service safely, and ensuring the underlying engineering problem is properly addressed rather than patched over.

You will work closely with other engineers in the team - providing technical input into implementation decisions, contributing to code quality, and helping less experienced engineers develop through code review, design discussion, and day-to-day technical engagement.

This role includes participation in an on-call rota. When on call, you are responsible for the services your team owns in production - responding to incidents, diagnosing issues, restoring service, and ensuring that lessons learned result in lasting improvements.

Role Requirements:

As a Senior Java Engineer in the Core Settlement team, you will be an active contributor responsible for both delivering and operating core application services

You will:

• Design, build and operate Java-based core settlement services supporting RTGS settlement
• Own complex changes across the core settlement estate, ensuring systems are correct, resilient and operable
• Shape and design software components, applying strong engineering principles (modularity, maintainability, separation of concerns)
• Make sound technical decisions, balancing pace, quality, resilience and long-term sustainability
• Ensure services meet performance, reliability and security expectations, including behaviour under load
• Improve how services behave in production (monitoring, recovery, operability and resilience)
• Work closely with the Solution Designer to translate designs into effective, incrementally deliverable software
• Take responsibility for production support, including on-call, incident diagnosis, service recovery and follow-up improvements
Contribute to engineering standards through code review, testing discipline and knowledge sharing

Minimum Criteria

We are looking for someone who has the following key skills and experience:

• Strong Java engineering experience building and supporting backend services in production
• Experience operating live systems, including incident response, troubleshooting and root cause analysis
• Experience with distributed systems, service-to-service interactions and event-driven patterns
• A strong testing discipline (unit, integration and component testing)
• Understanding of how software behaves in production (failure modes, recovery, operational risk)
Familiarity with CI/CD pipelines and container platforms (e.g. Jenkins, Kubernetes, OpenShift)

Essential Criteria

We are interested in hearing from candidates who demonstrate the following:

• Experience as a Senior/Lead Engineer owning design and delivery of backend services in complex environments
• Ownership of component-level design (structure, interfaces, modularity), not just implementation
• Experience building and operating systems where correctness and uptime are critical
• Experience diagnosing and improving performance in Java services (latency, throughput, memory, concurrency)
• Practical application of secure coding practices
• Experience supporting production systems as part of an on-call rota
• Ability to work closely with designers/architects, including challenging designs where needed
• A track record of improving engineering standards within a team
At least five years' experience working with backend Java services alongside complementary technologies such as relational databases (e.g. Oracle, PostgreSQL), event-streaming or messaging platforms (e.g. Kafka, RabbitMQ), and container orchestration platforms (e.g. OpenShift, Kubernetes).

Desirable Criteria

• It would also be beneficial, though not essential, to have some of the following:
• Financial services, payments, settlement systems, or other regulated / high-availability environments
• Building or supporting transaction processing or high-throughput backend systems
• Working with relational databases in enterprise environments, including SQL performance tuning and optimisation
• Messaging or event-driven architectures
• Modern production practices, including observability, monitoring, logging, metrics, alerting and tracing
• Testing approaches in service-based architectures (e.g. contract or consumer-driven testing)
• Supporting and developing other engineers in a senior capacity
• Working with standard engineering tooling (e.g. Git, Jenkins, Gradle, CI/CD pipelines, container platforms)
Experience working in scaled Agile environments (e.g. SAFe)

Don’t hesitate to apply if you don’t meet all of the criteria. We value diverse perspectives and believe different experiences lead to stronger teams and better outcomes.

How this role fits into the wider Bank:

RTGS Technology is moving to a product engineering model, with teams aligned to business and platform domains. The Core Settlement team sits at the heart of that model, owning the services responsible for settlement processing, settlement logic, transaction lifecycle execution, performance optimisation, and incident resolution within RTGS.

As a Senior Java Engineer in this team, you will contribute directly to the safety, resilience, and correctness of some of the most critical software in the UK financial system. You will work within delivery team that owns its services end-to-end - from design and build through to live operation -with clear accountability for what you ship and how it behaves.

You will work alongside other engineers with clear ownership of your area, and over time there will be opportunities to deepen your technical leadership within the team through engineering ownership, technical input into design, and influence over how the domain evolves.