Revolut Software Engineer interview questions & guide 2026

Interview questions at Revolut are designed to test core engineering practices under tight time constraints. Rather than purely abstract algorithmic puzzles, the technical assessments lean heavily toward practical backend challenges, concurrent programming, and production-ready system architecture.

Concurrency & Multi-threading

This category evaluates your ability to handle race conditions, design thread-safe execution flows, and ensure data integrity in parallel environments.

• How do you implement a thread-safe money transfer service between two accounts without causing deadlocks?
• Explain the difference between optimistic and pessimistic locking, and when you would use each in a relational database.

Preparing for an interview at Revolut requires a shift from standard LeetCode grinding to mastering practical backend engineering, TDD, and concurrent programming. You will be evaluated on your speed, operational rigor, and ability to deliver production-ready code under pressure.

Domain Knowledge & Backend Fundamentals
You must possess a deep understanding of core backend principles, specifically multi-threading, concurrency primitives, and relational database internals. Interviewers expect clear explanations of locking mechanisms, transaction isolation levels, and concurrency models (especially within JVM ecosystems like Java or Kotlin).

Production-Quality Execution
Writing functional code is only the baseline at Revolut. Interviewers evaluate whether your solution is modular, maintains clear abstraction boundaries, adheres to Domain-Driven Design (DDD), and includes comprehensive unit test coverage written via Test-Driven Development (TDD).

System Design & Scale Dynamics
For architecture rounds, you need to demonstrate how to build systems that handle failure gracefully. You will be evaluated on your understanding of distributed consensus, idempotency mechanisms, event-driven architectures (CQRS/Event Sourcing), and handling unreliable external dependencies.

Velocity & Technical Ownership
The interview process moves fast and tests your efficiency. You are expected to manage your time tightly, write working code quickly, ask clarifying questions up front, and justify your design trade-offs without defensive reasoning.

The hiring process at Revolut is fast-paced, highly structured, and rigorous. It typically spans three to four weeks from initial contact to offer, designed to evaluate both practical execution skills and core engineering depth.

The process transitions from an initial screening directly into hands-on technical validation. You will face live coding environments where you write code in your IDE, handle real-world backend scenarios, and answer targeted theory questions on databases and concurrency. System design rounds focus on real-world banking domain challenges rather than abstract concepts.

The timeline above reflects the typical progression for engineering roles. Early stages focus on execution speed and fundamentals, while later stages evaluate architectural depth and cultural alignment with Revolut’s high-ownership environment.

Concurrency & Low-Level System Design

Concurrency is a core evaluation area at Revolut. Because financial systems process thousands of parallel payment operations, engineers must write code that eliminates race conditions and avoids deadlocks.

Be ready to go over:

• Thread Synchronization – Mechanics of synchronized, explicit ReentrantLock, ReadWriteLock, and atomic variables in the JVM.
• Deadlock Prevention – Resource ordering strategies and lock timeout mechanisms when acquiring multiple locks across shared accounts.

As a Software Engineer at Revolut, your daily responsibilities center on building and maintaining resilient backend services that drive financial operations.

You will design and implement high-volume microservices using Java, Kotlin, or Scala. A significant portion of your work involves writing clean, maintainable domain code backed by relational databases like PostgreSQL. You will write robust unit and integration tests using TDD practices to ensure that system updates do not introduce regressions into live financial pipelines.

Collaboration is cross-functional and fast-paced. You will work closely with Product Managers, Operations teams, and System Architects to translate complex regulatory and product requirements into clear engineering deliverables. You will also participate in peer code reviews, contribute to architectural discussions, and take end-to-end ownership of your services from development to production monitoring and observability.

Candidates applying for the Software Engineer position at Revolut are expected to demonstrate strong engineering fundamentals, technical mastery in backend ecosystems, and clear ownership habits.

Technical Skills

• Must-have: Proficiency in backend technologies, specifically Java, Kotlin, or Scala. Strong proficiency with relational databases (especially PostgreSQL), SQL transaction isolation, and database locking mechanics.
• Must-have: Deep understanding of multi-threaded programming, concurrency control, and thread safety. Experience writing unit tests via Test-Driven Development (TDD).
• Nice-to-have: Hands-on experience with Event Sourcing, CQRS, Kafka, Docker, Kubernetes, and cloud infrastructure (AWS/GCP). Familiarity with Domain-Driven Design (DDD) principles.

Background & Soft Skills

• Must-have: Strong problem-solving skills under time pressure and the ability to articulate architectural decisions clearly. High ownership mindset with a focus on delivering production-ready solutions.
• Nice-to-have: Prior experience in fintech, core banking, high-frequency trading, or large-scale distributed systems platforms.

Q: How difficult are the technical interviews at Revolut?
The coding problems themselves are generally medium-level in algorithmic difficulty, but the overall bar is high due to tight time limits and strict criteria around code quality, TDD, concurrency, and production readiness.

Q: Which programming language should I use during live coding?
Java and Kotlin are the predominant languages used in Revolut’s backend stack and are highly recommended. However, you can generally use another language you are comfortable with, provided you can demonstrate solid concurrency handling and TDD.

Q: What is the main point of failure for candidates in technical rounds?
Candidates most often struggle by rushing to write code without setting up proper tests, ignoring edge cases, failing to explain concurrency trade-offs, or lacking deep knowledge of database isolation levels and locking mechanisms.

Q: What is the typical timeline from the initial screen to an offer?
The hiring process at Revolut is efficient and typically takes between three to four weeks. Feedback is generally provided rapidly between stages.

• Master TDD mechanics: Practice writing unit tests before or alongside your implementation logic. Interviewers value candidates who write clean, well-tested code over those who churn out unverified scripts.
• Brush up on PostgreSQL internals: Be ready to explain the differences between pessimistic and optimistic locking, index structures (B-Tree vs. BRIN), and transaction isolation levels in detail.
• Set up your local IDE environment in advance: Ensure your preferred IDE, test runners, and dependencies are pre-configured before live coding sessions to avoid losing time on setup errors.

• Communicate your design trade-offs proactively: When designing a system or writing code, explain why you chose a specific structure, data type (such as BigDecimal for currency), or locking mechanism.

A Software Engineer role at Revolut offers an exciting opportunity to work on large-scale financial software processing millions of operations daily. The engineering culture values velocity, strong technical depth, and rigorous execution. Success in the hiring process requires mastering backend fundamentals—specifically concurrency, database mechanics, TDD, and clean architecture design.

To give yourself the best advantage during preparation, approach your study deliberately: practice writing production-grade code quickly, review database internal structures, and refine your system architecture frameworks. You can explore additional interview insights, real candidate experiences, practice questions, and preparation resources on Dataford to refine your study plan.

The compensation data above reflects standard target packages for software engineering roles. Base pay, equity, and variable performance bonuses vary depending on candidate seniority, location, and demonstrated technical expertise during the interview process. Focused preparation on concurrency, TDD, and system design will help you demonstrate the technical depth needed to secure a competitive offer.