Revolut Mobile Engineer interview questions & guide 2026

Interview questions at Revolut are designed to test real-world software engineering, architecture, and core domain knowledge. The evaluation avoids abstract dynamic programming or obscure puzzle algorithms in favor of practical coding tasks, mobile system design scenarios, and deep dives into platform fundamentals.

Practical Live Coding & Data Layer Wiring

This category evaluates your ability to build feature extensions within an existing project, wire business logic to UI components, and handle concurrency cleanly.

• Given a half-written template project, connect a dummy data layer to the UI using Clean Architecture patterns.
• Implement a live-updating currency rate screen that polls an API every second, recalculates exchange values dynamically, and reorders UI elements on interaction.

Preparing for a mobile engineering position at Revolut requires demonstrating strong practical implementation skills rather than theoretical memorization. You must show that you write production-ready code rapidly, reason clearly about architecture, and take ownership of end-to-end user features.

Role-Related Technical Competency – You are expected to demonstrate deep mastery of your chosen platform stack (Android/Kotlin or iOS/Swift). Interviewers look for clean separation of concerns using Clean Architecture or MVVM, explicit handling of concurrency, thread safety, robust error management, and comprehensive unit testing.

System Design & Domain Pragmatism – In design evaluations, candidates must demonstrate an understanding of both client-side mobile structures and high-level backend integrations. You are evaluated on how well you handle data serialization, caching protocols, offline capabilities, state synchronization, and long-polling or WebSocket connections.

Ownership & Bias for Action – Revolut values engineers who take complete responsibility for feature delivery. You can demonstrate this by discussing how you debug complex edge cases, make explicit architectural trade-offs, drive cross-functional alignment with backend and product partners, and measure product performance in production environments.

Cultural Alignment & Direct Communication – Communication must be clear, concise, and grounded in data or explicit engineering principles. Interviewers look for candid problem solvers who handle direct feedback constructively, articulate decisions directly without fluff, and understand how mobile initiatives drive key business metrics.

The hiring loop for a Mobile Engineer at Revolut moves quickly and focuses heavily on practical execution. Rather than testing abstract algorithms, the process evaluates how effectively you write code, design client systems, and collaborate within a high-performance engineering organization.

The candidate journey begins with recruiter and screening calls to establish background alignment, followed by practical technical screens. As you progress into the core onsite stages, you will navigate hands-on live project coding, full-stack client/backend system design, and multiple team-fit rounds.

The timeline above outlines the standard candidate journey from initial contact to offer. You should use this flow to structure your prep: dedicate early preparation to deep platform fundamentals and live coding practice in your local IDE, followed by client-server system design practice prior to the design and team-fit rounds.

Practical Live Coding & Codebase Extension

This stage evaluates your capability to jump into an existing, structured project, comprehend the architecture quickly, and complete incomplete features or fix real-world bugs within a tight timeframe.

You will be handed a template project (e.g., in Android Studio or Xcode) containing a partially written feature. You will be asked to connect local data sources or mock network services to the UI, enforce a Clean Architecture pattern, manage async state, fix concurrency issues, and write valid unit tests to verify your implementation.

Be ready to go over:

• Architecture Wiring – Connecting raw data layer outputs to domain logic and exposing UI state through MVVM or reactive state streams.

Platform & Engineering Fundamentals

This area assesses your deep knowledge of platform-specific frameworks, memory management models, and core Computer Science concepts that impact mobile performance.

Interviewers will query your understanding of the underlying platform runtime. Rather than asking high-level framework questions, they evaluate whether you understand what happens beneath abstractions like reactive libraries, UI layout engines, and memory management loops.

Be ready to go over:

• Language & Runtime Internals – Execution mechanics of primitives, object lifecycle management, memory management (ARC on iOS, GC internals on Android), and data structure implementations like HashMap internals.
• Async Execution Models – Deep dive into Coroutines, Kotlin Flow, RxSwift/RxJava, or Combine/Swift Concurrency (async/await), focusing on cancellation, thread context switching, and error propagation.
• UI Framework Performance – Understanding view inflation, view holder patterns, layout passes, recycling mechanics in RecyclerView or UICollectionView, and performance tuning for complex layouts.
• Advanced concepts (less common) – Binary size reduction strategies, custom dynamic feature module delivery, and low-level dynamic framework linking.

Example scenarios:

• "Explain step-by-step how a HashMap stores and retrieves key-value pairs, how collision resolution works under the hood, and what thread-safety issues occur when accessed concurrently without synchronization."
• "How do Coroutines manage cancellation in structured concurrency? What happens to child jobs when a parent job fails, and how does this differ from un-handled errors in Rx reactive streams?"

Leadership, Execution & Cultural Fit

Team-fit and leadership conversations at Revolut evaluate your operational mindset, cross-functional collaboration, and alignment with company execution standards.

Instead of informal chats, these rounds follow structured formats. Interviewers score candidates against explicit competencies, including ownership, communication clarity, ability to work cross-functionally with Product, Backend, and Data teams, and focus on business outcomes.

Be ready to go over:

• Production Ownership – Demonstrating how you own features end-to-end, monitor production telemetry, handle outages, and fix regression issues post-launch.
• Cross-Functional Collaboration – How you align technical specifications with backend engineers, product managers, and UI designers to ensure smooth feature delivery.
• Pragmatic Decision Making – Explaining how you balance architectural purity against launch targets, technical debt management, and business imperatives.
• Advanced concepts (less common) – Incident response command structures and driving organizational refactoring initiatives across multiple independent mobile feature pods.

Example scenarios:

• "Tell me about a project where you had to make a difficult technical trade-off to meet a tight product delivery deadline. What did you compromise, how did you manage the technical debt, and what was the business impact?"
• "How do you handle a situation where backend API specifications provided by another team do not meet the performance or data structure requirements of your mobile UI?"

As a Mobile Engineer at Revolut, you take full ownership of feature modules within the mobile codebase. You are responsible for designing, building, testing, and maintaining core mobile services used by millions of customers across global jurisdictions.

You will collaborate daily with multi-disciplinary feature teams consisting of product managers, backend engineers, data specialists, and UI/UX designers. Your responsibility extends beyond writing mobile code; you participate actively in API contract design, technical specification reviews, and operational telemetry monitoring for your team's domains.

• Feature Implementation & Architecture – Design and ship modular, clean, and robust features using Kotlin or Swift, adhering strictly to Clean Architecture principles and team quality guidelines.
• Performance Optimization – Identify and eliminate performance bottlenecks, memory leaks, high battery usage, and network inefficiency to maintain sub-second UI responsiveness.
• Quality Assurance & Automated Testing – Write comprehensive unit and integration test suites for core business logic, state machines, and view models to protect against regressions.
• Cross-Functional Alignment – Work with backend developers to design efficient REST and WebSocket APIs, while collaborating with product managers to clarify technical requirements and edge cases.
• Production Maintenance & Monitoring – Monitor application crashes, performance analytics, and user telemetry in production, rapidly responding to critical regressions or outages.

Candidates applying for the Mobile Engineer role are evaluated on practical mobile development expertise, production discipline, and core Computer Science foundations.

Must-Have Qualifications

• Platform Technical Mastery – Strong proficiency in modern mobile development using Kotlin (Android) or Swift (iOS), along with deep familiarity with core system SDKs.
• Architecture & Design Principles – Demonstrated hands-on experience structuring mobile codebases using Clean Architecture, MVVM, and modern reactive state management patterns.
• Concurrency & Thread Safety – Proven ability to write safe multi-threaded code using Coroutines, Flow, GCD, Combine, or async/await, including deep knowledge of thread-safe data structures.
• Automated Testing Discipline – Track record of writing unit and integration tests as a core part of the feature development lifecycle.
• Pragmatic Problem Solving – Ability to rapidly parse existing code, debug complex edge cases, and deliver working production solutions under timed constraints.

Nice-to-Have Qualifications

• Full-Stack & Client-Server Awareness – Experience participating in backend API design, working with gRPC, GraphQL, or REST frameworks, and understanding server-side data models.
• Reactive Programming Foundations – Hands-on experience with legacy or core reactive frameworks like RxJava, RxKotlin, or RxSwift.
• Modern UI Framework Experience – Familiarity with Jetpack Compose (Android) or SwiftUI (iOS), alongside legacy view engines like XML/ConstraintLayout or UIKit.
• Financial Services Domain Knowledge – Understanding of financial security standards, dynamic local caching of transaction feeds, or working with payment integration frameworks.

Q: How algorithmic or puzzle-focused are Revolut's mobile coding rounds? Revolut focuses heavily on practical mobile engineering rather than abstract dynamic programming or complex graph theory algorithms. You will be evaluated on practical coding: extending half-written project templates, connecting data layers to UI components, managing thread safety, and writing clean unit tests in your platform's native tools.

Q: What is expected during the Mobile System Design round? The design round tests both client-side architecture and how the app interacts with backend systems. You are expected to design local data flow, state management, caching mechanisms, and offline syncing, while also defining API specs and discussing high-level backend integrations.

Q: What is the tone and format of the Team Fit rounds? Team-fit interviews at Revolut are structured evaluations rather than informal chats. Interviewers assess candidates against specific core competencies, such as ownership, direct communication, cross-functional collaboration, and business impact. Be prepared to give clear, structured answers backed by real engineering experiences.

Q: Are Android candidates expected to know modern Compose or legacy XML views? While Revolut continues to modernize its stack, key parts of the existing codebase rely on XML layouts, RecyclerView, and ConstraintLayout. Demonstrating strong proficiency in core XML view recycling mechanics alongside clean architectural separation will serve you well during practical coding interviews.

Q: How fast does the Revolut interview loop move? The hiring process generally proceeds quickly, with recruiter debriefs and scheduling occurring between rounds. However, because candidates must pass each distinct technical milestone before proceeding to subsequent stages, thorough preparation for both practical live coding and system design is necessary before beginning the process.

• Master standard project wiring in your IDE: Practice building features inside partial Android Studio or Xcode projects quickly. Focus on setting up a view model, wiring a data source to the UI, handling loading/error states, and writing a unit test within 45 to 60 minutes.
• Brush up on core data structures and thread safety: Be prepared to explain and demonstrate the mechanics of collections like HashMap, concurrent queues, and atomic variables under multi-threaded read/write workloads.
• Be direct and concise in team fit interviews: Present your engineering experience clearly without fluff. Emphasize ownership, describe decisions in terms of technical trade-offs, and explicitly tie technical improvements to user and business outcomes.

• Take clear notes during recruiter prep calls: Recruiters at Revolut frequently offer helpful context on evaluation focus areas for upcoming rounds. Pay close attention to these guidelines and tailor your preparation accordingly.

A Mobile Engineer position at Revolut offers the opportunity to build high-volume financial features used by tens of millions of people worldwide. The engineering culture values high speed, operational ownership, clean architecture, and technical execution. Because the evaluation process centers on real-world coding and client-server system design, dedicated prep targeting practical implementation yields direct results.

To maximize your performance, focus your preparation on core platform mechanics: practice connecting multi-layered template apps in your IDE under timed conditions, review structured concurrency and thread safety patterns, and practice leading client-server mobile system design discussions end-to-end. Ground your behavioral responses in concrete technical achievements that highlight ownership, collaboration, and measurable business impact.

To further accelerate your preparation, explore detailed interview insights, candidate-reported question breakdowns, and tailored technical prep resources on Dataford.

The compensation data above reflects total target earnings for mobile engineering roles at Revolut. Base salary ranges vary depending on seniority, geographic location, and local market bands, and are frequently complemented by equity incentives or performance bonuses. Candidates should evaluate offered compensation packages based on base pay structure, location considerations, and equity vesting terms.