Revolut Software Engineer interview questions & guide 2026

The questions encountered during the Revolut Software Engineer interview process are highly practical and representative of real production challenges. Rather than abstract brainteasers, interviewers focus heavily on multithreading, concurrency control, database transaction mechanics, production-quality API design, and distributed architecture.

Coding & Multithreading

This category evaluates your ability to build production-grade, thread-safe software under strict time constraints. Interviewers expect well-structured, production-ready code with clean class designs, robust error handling, and unprompted unit tests written using Test-Driven Development (TDD).

• Implement an in-memory Load Balancer Service supporting registerServer() along with Random and Round Robin distribution strategies in a thread-safe manner using TDD.
• Build an Account Ledger Service handling concurrent deposit, withdraw, and transfer operations between accounts while preventing race conditions and deadlocks.

Preparing for an engineering interview at Revolut requires a shift from standard algorithmic practice to production-level code craftsmanship and core backend mechanics. Interviewers evaluate how you write code under pressure, whether you instinctively account for race conditions, and if you understand database operations down to the engine level.

Role-Related Knowledge – You must demonstrate deep fluency in backend engineering, particularly within the Java or Kotlin ecosystems. Interviewers evaluate your mastery of PostgreSQL internals, thread safety, synchronization primitives, and microservices design patterns like CQRS and DDD.

Production Engineering & TDD – At Revolut, code that merely passes functional inputs is not enough. You are expected to demonstrate strong engineering discipline by writing unit tests alongside or before implementation (TDD), organizing domain models cleanly, validating edge cases, and anticipating failure scenarios unprompted.

System Design & Resilience – Evaluation focuses on your ability to handle real-world operational challenges such as database lock contention, network latency, unreliable third-party APIs, and eventual consistency. You will succeed by making explicit architectural trade-offs, emphasizing idempotency, and demonstrating operational depth.

Ownership & Culture Alignment – Revolut operates in a fast-paced, high-intensity environment that values speed, directness, and end-to-end accountability. You are assessed on how clearly you explain past decisions, quantify impact with hard metrics, and take direct ownership of outcomes.

The interview pipeline for a Software Engineer at Revolut is fast, structured, and technically demanding. The process is designed to eliminate ambiguity by assessing concrete core skills early. While exact stage sequencing can vary slightly depending on candidate level or specific team needs, the core loop is standardized across locations.

Candidates typically start with an automated Online Assessment (OA) or an initial recruiter screening call that includes direct technical screening questions. Passing candidates transition into intensive live coding and technical discussion rounds, followed by a full system design evaluation, before culminating in a hiring manager or culture-fit conversation.

The defining characteristic of the Revolut process is its fast execution paired with a high technical bar. Time management during live rounds is critical: coding sessions expect fully functional, tested, and thread-safe implementations within 30 to 45 minutes, while technical discussions move rapidly through detailed database and multithreading concepts.

This visual timeline illustrates the primary progression through the interview pipeline. Candidates should prepare for tight turnarounds between stages and maintain high energy throughout, as each stage acts as a strict eliminator for subsequent rounds.

Live Coding & TDD Architecture

Live coding at Revolut tests your practical ability to translate business requirements into thread-safe, modular, and fully tested code. You will write code in an IDE environment where clean domain modeling and testing practices are scrutinized as closely as functional logic.

Be ready to go over:

• Test-Driven Development (TDD) – Writing unit tests first (using frameworks like JUnit, Spock, or standard test runners) to validate happy paths and boundary conditions.
• Thread Safety & Concurrency – Applying synchronization primitives (synchronized, ReentrantLock, AtomicInteger, ConcurrentHashMap) appropriately without introducing performance bottlenecks or deadlocks.

As a Software Engineer at Revolut, your day-to-day work centers around designing, implementing, and maintaining high-throughput backend services. You will join an autonomous product or platform team, working directly alongside product owners, site reliability engineers, and data analysts to deliver resilient financial features.

Primary responsibilities include:

• Developing Core Banking & Financial Services: Writing clean, performant Java or Kotlin backend code to power money transfers, card processing, FX trades, and customer management services.
• Ensuring System Reliability & Data Integrity: Architecting fault-tolerant microservices that handle high concurrency with zero data loss, leveraging robust database isolation and distributed locking techniques.
• Driving Automated Quality: Writing comprehensive unit, integration, and end-to-end test suites using TDD to maintain high test coverage across mission-critical services.
• Collaborating on System Design: Participating in architectural reviews, authoring technical design documents, and defining system interfaces using DDD and CQRS principles.
• Monitoring & Production Support: Taking ownership of service performance in production, debugging complex multi-service issues using observability tools, and optimizing database queries and resource usage.

Candidates applying for the Software Engineer position at Revolut are expected to possess strong core computer science fundamentals and hands-on experience with production backend stack components.

Must-Have Skills

• Strong Backend Proficiency: Advanced knowledge of Java or Kotlin (or equivalent OOP languages like Python/Scala for specific specialized roles).
• Concurrent Programming: Mastery of multithreading, synchronization primitives, thread safety, race condition prevention, and concurrent collections.
• Database Expertise: Deep experience with relational databases, specifically PostgreSQL, including raw SQL proficiency, index tuning, transaction isolation, and locking strategies.
• Software Engineering Discipline: Proven experience with Test-Driven Development (TDD), object-oriented design, SOLID principles, and unit testing frameworks.
• System Design Fundamentals: Understanding of distributed microservices, messaging queues, RESTful API design, and caching layers.

Nice-to-Have Skills

• Fintech & Banking Domain Knowledge: Prior experience building transaction ledgers, payment gateways, or multi-currency accounting systems.
• Advanced Architectural Patterns: Hands-on familiarity with CQRS, Event Sourcing, and Domain-Driven Design (DDD).
• Infrastructure & DevOps Tools: Familiarity with Docker, Kubernetes, Patroni, Prometheus, Loki, and automated CI/CD pipelines.

Q: How difficult are the live coding rounds compared to standard LeetCode style interviews? Rather than pure algorithmic LeetCode puzzles, Revolut live coding focuses on practical system component implementation (e.g., designing an in-memory load balancer or ledger). The difficulty lies in completing a fully tested (TDD), thread-safe implementation with clean object-oriented architecture within a strict 30–45 minute time frame.

Q: Is Java mandatory, or can I use other languages during the interview? While Revolut's stack is predominantly Java and Kotlin, candidates can often complete live coding tasks in other major languages such as Python or Scala depending on the specific team. However, deep familiarity with Java core concepts, JVM execution mechanics, and Java concurrency models is heavily advantageous during technical discussions.

Q: What is the single biggest factor that causes candidates to fail system design? System design candidates often fail by staying too high-level with generic cloud components instead of diving into domain specifics. Interviewers expect you to explicitly detail data schemas, transaction handling, locking strategies, idempotency keys, and how you prevent edge-case state inconsistencies during third-party integration failures.

Q: How long does the entire hiring process take from start to offer? The hiring pipeline is fast-paced and typically takes between 2 to 4 weeks depending on scheduling availability. Candidates often move quickly between rounds, provided feedback at each stage meets the passing bar.

Q: Does Revolut offer remote or hybrid working arrangements? Revolut supports hybrid and flexible remote working models depending on location and team structure, though candidates are expected to align with their core team's working hours and high-velocity shipping cadence.

• Prioritize TDD from minute one: Do not wait for the interviewer to prompt you to write tests. Define your test cases upfront and build your code iteratively against them during live coding.
• Master explicit database locking syntax: Be comfortable discussing and writing raw SQL statements utilizing FOR UPDATE and explaining the trade-offs of different transaction isolation levels.
• Practice explicit time management: The coding and system design interviews are tightly timed. Keep your code simple first, establish working functionality and test coverage, then optimize for concurrency and edge cases.

• Brush up on concurrency primitives: Be ready to clearly articulate when to use synchronized, ReentrantLock, Atomic variables, or thread-safe collection structures, explaining how each impacts throughput.
• Communicate your architectural trade-offs loudly: In system design, clearly explain why you chose a specific pattern (e.g., pessimistic locking over optimistic locking, or asynchronous saga over synchronous REST calls).

Targeting a Software Engineer role at Revolut requires a rigorous, focused approach to technical preparation. By demonstrating mastery over thread-safe programming, Test-Driven Development, deep database mechanics, and resilient system design, you position yourself as a production-ready engineer who can deliver value immediately.

Focus your practice on core backend implementations: practice building in-memory ledger services and load balancers, review PostgreSQL isolation levels and lock behaviors, and refine your approach to distributed system consistency. Approaching each interview stage with clarity, speed, and thorough engineering discipline will maximize your performance throughout the process.

To further accelerate your interview preparation, explore detailed, real-world candidate experiences, technical breakdown guides, and company-specific question sets available on Dataford.

The provided compensation data reflects total target earning ranges across technical engineering levels. Base pay, performance bonuses, and equity components vary based on candidate seniority, location, and specific team placement. When evaluating compensation, candidates should consider the complete target package alongside opportunities for rapid internal advancement.