Senior Backend Engineer - Java/Architecture

Watu

3d • Remote

About The Position

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.

Requirements

• 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 them.
• Java 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 territory.
• REST API design - you know what makes a good API (versioning, error handling, idempotency, pagination) and you design accordingly, not just implement to spec.
• Relational database design - schema design, indexing, query optimisation, and understanding the performance implications of your data model choices.
• Distributed 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 them.
• Testing - 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.
• All code in GitHub - mandatory peer review, unified branching strategy, green CI before merge.
• APIs documented with OpenAPI/Swagger; Architecture Decision Records for significant decisions.
• No secrets in code - AWS Secrets Manager or Vault.
• OWASP Top 10 awareness is a baseline expectation.
• AI/LLM tooling used actively in your daily workflow - code generation, test writing, documentation, debugging.

Nice To Haves

• 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 platform.
• Microservices architecture experience - service discovery, API gateways, inter-service communication patterns, distributed tracing.
• Cloud environment familiarity - AWS in particular. Not infrastructure ownership, but enough fluency to understand the environment your services run in.
• Experience with any additional JVM language (Kotlin) or willingness to learn - some squads may introduce Kotlin for new services.
• Fintech, payments, or financial services domain experience - understanding of reconciliation, idempotency in payment flows, and audit logging requirements.
• Readable, well-named, well-structured code is a professional standard, not an optional extra.
• You ask questions early when requirements are unclear rather than building something and discovering the misunderstanding in sprint review.
• You 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.

Responsibilities

• Design, build, and maintain backend services and APIs consumed by other squads, external partners, and customer-facing products.
• Write unit and integration tests as a first-class part of development - not as a separate phase, not as something the QA engineer handles for you.
• Drive 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 others.
• Review 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 better.
• Write and maintain technical documentation: API specs (OpenAPI), service READMEs, runbooks for systems you own. If you built it, you document it.
• Contribute to shared libraries and platform standards when your work has cross-squad value.
• Use AI/LLM tooling actively in your workflow - code generation, test writing, debugging, documentation. We expect this, not just permit it.

What This Job Offers

• Job Type: Full-time
• Career Level: Senior
• Education Level: No Education Listed