Summary
A mystery fintech employer operating across emerging markets is hiring a Senior Backend Engineer based in Europe (remote). You will own a domain end-to-end within a small squad, drive architecture discussions, write clean Java/Spring Boot services, design resilient distributed systems, and uphold high engineering standards with AI-assisted workflows. 5+ years backend experience with deep Java production use required.
Highlights
Fully remote role in Europe with significant autonomy, modern engineering standards including mandatory code review and AI tooling, ownership of backend domain and architecture decisions, fintech scale impact across emerging markets, strong learning culture with intellectual honesty.
Description
Senior Backend Engineer (Java / Architecture)
Watu
Technology Organisation Reports to Tech Lead
Location
Europe
Reports to
Tech Lead of assigned squad
Primary language
Java (Spring Boot) - architecture depth and system design expected, not Java-only focus
Seniority
Senior - 5+ years
About Watu
Watu is a fintech company operating across Africa and Latin America, providing device financing and financial services to customers historically excluded from the formal financial system.
We finance motorcycles, smartphones and other productive assets through a technology-first, data-driven approach - enabling customers to own income-generating assets and build credit histories.
Our platform supports millions of customer journeys across Kenya, Uganda, Tanzania, Ivory Coast, Ghana, and beyond, with continued expansion into LATAM.
The Role
Senior Backend Engineer at Watu means owning a domain end-to-end inside your squad - and influencing how that domain evolves.
You write code, but you also shape the system.
You bring architectural opinions that the Tech Lead can rely on, you raise the quality bar for the engineers around you, and you take full responsibility for the reliability and maintainability of what you build.
We use Java as our primary backend language, but we do not hire Java developers who only think about Java.
We hire engineers who happen to use Java.
The difference matters: we want people who can reason about distributed systems, design clean APIs, think about failure modes before they happen, and care about the downstream consumer of their code as much as the implementation.
You will be embedded in a squad of 4โ6 people.
Your Tech Lead is your primary technical counterpart and reviewer, but at the senior level the expectation is that you operate with significant autonomy.
You are not waiting to be told what to build or how to solve a problem - you bring a point of view, surface design decisions proactively, and contribute to the direction of your domain.
What You Will Do
Design, build, and maintain backend services and APIs consumed by other squads, external partners, and customer-facing productsWrite unit and integration tests as a first-class part of development - not as a separate phase, not as something the QA engineer handles for youDrive architecture discussions within your squad - propose designs, write Architectural Decision Records, and defend technical choices clearly.
At the senior level you are an active contributor to how the system evolves, not just an implementer of decisions made by othersReview pull requests with depth and directness.
Your reviews go beyond correctness - you assess design, maintainability, performance, and test coverage.
You are a quality benchmark for the squad, and your reviews make engineers betterWrite and maintain technical documentation: API specs (OpenAPI), service READMEs, runbooks for systems you own.
If you built it, you document itContribute to shared libraries and platform standards when your work has cross-squad valueUse AI/LLM tooling actively in your workflow - code generation, test writing, debugging, documentation.
We expect this, not just permit it
Who You Are
Technical - essential
5+ years of professional backend software engineering experience, with at least 3 years working in Java in a production environment at a level where you were making design decisions, not just implementing themJava and Spring Boot depth - you understand the framework, not just its syntax.
Dependency injection, Spring Security, Spring Data, transaction management, and testing with Spring Test are all familiar territoryREST API design - you know what makes a good API (versioning, error handling, idempotency, pagination) and you design accordingly, not just implement to specRelational database design - schema design, indexing, query optimisation, and understanding the performance implications of your data model choicesDistributed systems depth - proven experience with eventual consistency, idempotency, retry logic, circuit breakers, and failure mode design in a real production system.
You have debugged these problems at 2am, not just studied themTesting - unit tests with JUnit/Mockito, integration tests with a real database, and enough understanding of the test pyramid to know when to use each level
Technical - strongly preferred
Event-driven architecture in production - Kafka or equivalent at real operational depth.
Consumer groups, offset management, at-least-once vs exactly-once delivery.
This is not a nice-to-have at the senior level; it is part of the core platformMicroservices architecture experience - service discovery, API gateways, inter-service communication patterns, distributed tracingCloud environment familiarity - AWS in particular.
Not infrastructure ownership, but enough fluency to understand the environment your services run inExperience with any additional JVM language (Kotlin) or willingness to learn - some squads may introduce Kotlin for new servicesFintech, payments, or financial services domain experience - understanding of reconciliation, idempotency in payment flows, and audit logging requirements
Beyond the code
You care about the people reading your code as much as the compiler.
Readable, well-named, well-structured code is a professional standard, not an optional extraYou ask questions early when requirements are unclear rather than building something and discovering the misunderstanding in sprint reviewYou are honest about what you do not know and willing to learn in public.
The engineering culture at Watu rewards intellectual honesty over false confidence
Engineering standards you are expected to uphold
All code in GitHub - mandatory peer review, unified branching strategy, green CI before mergeAPIs documented with OpenAPI/Swagger; Architecture Decision Records for significant decisionsNo secrets in code - AWS Secrets Manager or Vault.
OWASP Top 10 awareness is a baseline expectationAI/LLM tooling used actively in your daily workflow - code generation, test writing, documentation, debugging
How to Apply
Send your CV and a brief note on why this role to the Watu talent team.
We run a structured process: an initial conversation with the relevant Head of Engineering, a technical interview, and a final conversation with the wider leadership team.
We move quickly for the right candidate.
We are an equal opportunity employer and actively work to build a team that reflects the diversity of the markets we serve.
All personal information provided will be processed in accordance with applicable data protection laws and regulations and used solely for recruitment and selection purposes.
Watu
Technology Organisation Senior Backend Engineer
Powered by JazzHR
Jmij7tunT1