← Revolut Interview Insights

Revolut·Backend Engineer·Technical Phone Screen·Senior

Senior
May 2026

Summary

Backend-heavy Q&A round at Revolut covering distributed systems, database internals, and some architecture design. The questions were meaty and ranged from very practical to pretty theoretical. Not a lot of coding, mostly talking through how things work under the hood.

Questions Asked (4)

Q1

How does a global bank like Revolut keep its databases consistent across multiple geographic regions?

System DesignTechnical Trade-offs
Author's notes

This one went longer than I expected.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: consistency level (strong vs eventual), latency tolerance, and regulatory constraints. Then discuss a multi-region architecture using a combination of synchronous replication for critical data (e.g., financial transactions) and asynchronous replication for less critical data, with conflict resolution strategies. Conclude by highlighting trade-offs and how Revolut might tailor the approach to its specific needs.

Pro tip: Emphasize that consistency is a spectrum and that the right choice depends on the business impact of stale or conflicting data—showing you understand trade-offs beyond just technical implementation.

1. Clarify Requirements

Ask about consistency requirements (strong vs eventual), latency SLAs, and regulatory constraints like data residency. This shows you won't jump to solutions without understanding the problem.

2. Choose a Replication Strategy

Discuss synchronous replication for critical data (e.g., account balances) to ensure strong consistency, and asynchronous replication for less critical data to reduce latency. Mention quorum-based approaches like Paxos or Raft for consensus.

3. Address Conflict Resolution

Explain how to handle conflicts in multi-region writes, such as using last-write-wins, vector clocks, or CRDTs. Highlight that financial data often requires avoiding conflicts altogether by routing writes to a primary region.

4. Discuss Trade-offs

Compare consistency, availability, and latency (CAP theorem). Explain how Revolut might prioritize consistency for transactions but availability for user profiles, and how they might use a hybrid approach.

5. Mention Real-World Implementations

Reference technologies like Google Spanner, CockroachDB, or Cassandra, and how they provide different consistency guarantees. Relate to Revolut's scale and likely use of a multi-region database.

Key Points to Mention

  • CAP theorem and the trade-off between consistency and availability
  • Synchronous vs asynchronous replication and their impact on latency
  • Consensus algorithms (Paxos, Raft) for strong consistency
  • Conflict resolution techniques (CRDTs, vector clocks, last-write-wins)
  • Data partitioning and sharding to localize data and reduce cross-region traffic
  • Regulatory requirements like GDPR and data residency that influence architecture

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

Walk me through how a database handles multiple concurrent transactions without corrupting data.

System DesignTechnical Trade-offs
Author's notes

Felt more comfortable here.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining the problem: concurrent transactions can cause lost updates, dirty reads, and other anomalies. Then explain the mechanisms databases use to prevent corruption, such as locking, MVCC, and isolation levels, and how they trade off consistency and performance. Finally, tie it back to real-world systems like PostgreSQL or MySQL and mention how you'd choose the right approach for a given workload.

Pro tip: Mention that most databases default to Read Committed isolation, but for critical financial operations you might need Serializable or explicit locking, and always consider the performance impact. Also, highlight that MVCC is not a silver bullet—it can lead to bloat and requires vacuuming.

1. Define the problem and anomalies

Explain what can go wrong with concurrent transactions: lost updates, dirty reads, non-repeatable reads, and phantom reads. This sets the stage for why concurrency control is needed.

2. Introduce core concurrency control mechanisms

Describe locking (pessimistic) and MVCC (optimistic) as the two main approaches. Explain how they work at a high level and their trade-offs.

3. Explain isolation levels and their guarantees

Walk through the SQL standard isolation levels (Read Uncommitted, Read Committed, Repeatable Read, Serializable) and what anomalies each prevents. Mention that implementations vary (e.g., PostgreSQL's Repeatable Read is actually snapshot isolation).

4. Discuss real-world implementation and trade-offs

Give examples from popular databases (e.g., PostgreSQL uses MVCC, MySQL InnoDB uses MVCC + locking). Discuss performance implications, deadlocks, and how to choose the right isolation level for a given use case.

5. Conclude with best practices and monitoring

Summarize that no single approach is perfect; it's about trade-offs. Mention the importance of monitoring for deadlocks, lock contention, and transaction duration, and using tools like EXPLAIN or database logs.

Key Points to Mention

  • ACID properties, especially Isolation and Durability
  • Two-phase locking (2PL) and its variants (strict 2PL)
  • Multiversion Concurrency Control (MVCC) and snapshot isolation
  • Isolation levels: Read Committed, Repeatable Read, Serializable
  • Deadlock detection and resolution strategies
  • Performance trade-offs: locking overhead vs. concurrency, MVCC bloat and vacuuming

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

A user is reporting that the app feels slow. How do you investigate that end to end?

Root Cause AnalysisSystem Design
Author's notes

Classic.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the symptom and scope (which users, platforms, actions, and when it started) to avoid chasing the wrong problem. Then walk through the full request path—client, network, API gateway, backend services, databases, and dependencies—using metrics, logs, and traces to localize the bottleneck. Finally, validate the root cause with a hypothesis-driven test and propose a fix with monitoring to prevent recurrence.

Pro tip: Emphasize that 'slow' is not a metric—immediately push for quantifiable data like p95/p99 latency, error rates, and throughput, and correlate with recent deployments or config changes. This shows you think like a production engineer, not just a troubleshooter.

1. Clarify and quantify the issue

Ask targeted questions to define 'slow': which user segments, specific endpoints or actions, frequency, and when it started. Gather concrete metrics like response times, error rates, and affected user percentage.

2. Map the end-to-end request flow

Outline the full path from client to backend: mobile/web app, CDN, load balancer, API gateway, microservices, databases, caches, and third-party services. Identify where latency could be introduced at each hop.

3. Use observability data to localize the bottleneck

Leverage distributed tracing, metrics (latency histograms, CPU, memory, I/O), and logs to pinpoint which component is slow. Compare current performance against baselines and check for anomalies.

4. Form and test hypotheses

Based on data, hypothesize likely causes (e.g., database query regression, thread pool exhaustion, network latency, downstream dependency slowdown). Validate with targeted experiments or by reproducing in a staging environment.

5. Resolve and prevent recurrence

Implement a fix (e.g., optimize query, scale resource, add caching) and verify improvement. Add monitoring/alerting for the specific metric and conduct a post-mortem to share learnings.

Key Points to Mention

  • Distributed tracing (e.g., Jaeger, Zipkin) to follow a request across microservices
  • Metrics: p50/p95/p99 latency, error rates, throughput, saturation (CPU, memory, I/O)
  • Log aggregation and correlation IDs to trace specific user sessions
  • Database query performance (slow query logs, indexing, N+1 queries)
  • Caching layers (Redis, CDN) and their hit/miss ratios
  • Recent changes: deployments, feature flags, config updates, traffic spikes

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q4

What is domain-driven design and how does it differ from CQRS?

System DesignTechnical Trade-offsData Modeling
Author's notes

Blanked for a second because I wasn't expecting a pure architecture concepts question in what felt like a systems round.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining domain-driven design (DDD) as a strategic approach to modeling complex business domains, then clarify that CQRS is a tactical pattern for separating read and write models. Emphasize that they are not alternatives but complementary, and discuss how they can be combined in a system like Revolut's.

Pro tip: Mention that DDD helps align software with business language and boundaries, while CQRS addresses specific performance and scalability concerns; using both together can lead to a more maintainable and scalable system, but be cautious of over-engineering.

1. Define DDD

Explain that DDD is a software design approach focused on modeling the core business domain, involving ubiquitous language, bounded contexts, and collaboration with domain experts.

2. Define CQRS

Describe CQRS as a pattern that separates read and write operations into different models, often using different data stores, to optimize performance, scalability, and security.

3. Clarify the Relationship

Highlight that DDD is strategic and broad, while CQRS is tactical and specific; they operate at different levels and can be used together, but neither implies the other.

4. Discuss Trade-offs and Use Cases

Talk about when to use each: DDD for complex domains with rich business logic, CQRS for systems with high read/write disparity or needing separate scaling; mention potential complexity and consistency challenges.

5. Relate to Revolut's Context

Connect to Revolut's needs: DDD for modeling financial domains (e.g., payments, accounts), CQRS for high-throughput transaction systems where reads and writes have different patterns.

Key Points to Mention

  • Ubiquitous language and bounded contexts in DDD
  • CQRS separates commands (writes) from queries (reads)
  • DDD is strategic; CQRS is tactical
  • They can be complementary: DDD defines boundaries, CQRS optimizes within them
  • Event sourcing is often used with CQRS but is not required
  • Trade-offs: increased complexity, eventual consistency, need for team maturity

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.