
When I received my Revolut HackerRank online assessment invitation after applying for a Backend Software Engineer role, I almost prepared for the wrong type of test. Most big tech OAs throw random dynamic programming brainteasers at you and only care whether your output matches a text file. Revolut is completely different. Because Revolut operates a global high-concurrency banking, foreign-exchange (FX), and payments platform, its HackerRank assessment tests a brutal combination of clean production-style Object-Oriented Design (thread safety, lock ordering, and boundary validation) alongside FinTech-flavored algorithms and point-in-time SQL queries.
During my 75-minute HackerRank session, I faced a multi-part Service Load Balancer & Instance Registry problem, a Sliding-Window Card Fraud Velocity Detector, and a Multi-Currency FX Graph Conversion problem. On the concurrent state logic, a subtle race condition around round-robin index wrapping and duplicate URI registration nearly cost me several hidden unit tests until I used an AI interview assistant to verify the thread-safe lock granularity and modulo edge cases.
In this complete guide, I am sharing my Revolut HackerRank online assessment questions along with the broader 2025–2026 Revolut HackerRank question bank I collected from fellow Backend SWE (Java/Kotlin/Python/Go), Rev-celerator Graduate/Intern, Frontend, and Data/Analytics Engineer candidates. I will walk you through the exact working Python and SQL solutions, the concurrency traps that get candidates rejected even when sample tests pass, how HackerRank's proctoring and Code Playback catch shortcuts, and how I use Linkjob AI in both Desktop Floating Window Mode and Dual-Device Mode to clear the assessment safely without triggering a single flag.
Revolut sends its HackerRank Online Assessment (OA) right after your initial CV screening (or immediately after a 15-minute recruiter screening call) across its London HQ, Krakow, Porto, Madrid, Barcelona, Berlin, Vilnius, Bangalore, and remote engineering hubs. Depending on which role family you applied to, your HackerRank link will load one of four distinct configurations.
This is Revolut's flagship engineering assessment, and it catches pure LeetCode grinders off guard every single week.
Format and Timer: Typically 60 to 90 minutes containing 2 to 3 coding problems—usually pairing 1 production-grade OOP / concurrency design task (such as building a thread-safe Load Balancer, URL Shortener, or Deadlock-Free Money Transfer Ledger) with 1 to 2 algorithmic problems (sliding window fraud detection, currency conversion graphs, or interval merging).
How Revolut Grades Backend Code: Unlike automated tests that only check stdout, Revolut's HackerRank unit-test suite runs reflection and concurrency tests against your class methods, and a human Revolut engineer frequently inspects your Code Playback and class structure before inviting you to the live TDD (Test-Driven Development) coding interview. Writing spaghetti code inside a single 150-line method with single-letter variables (a, b, x) can get you rejected even if the green checkmarks appear.
For campus, internship, and early-career Rev-celerator candidates, the HackerRank assessment typically runs 75 to 90 minutes with 3 algorithmic coding problems progressing from Easy-Medium to Medium-Hard:
Problem 1 (Warmup): String parsing (IBAN / card-number Luhn checksum validation), hash-map frequency counting, or time-interval overlap checking.
Problem 2 (Medium): Sliding window transaction limits, monotonic stacks, or BFS/DFS graph traversal.
Problem 3 (Medium-Hard Separator): Weighted graph shortest paths (Dijkstra / Bellman-Ford for currency exchange rates), prefix-sum modulo subarrays, or dynamic programming.
Revolut is famous for its heavily quantitative, SQL-driven culture. If you applied for an Analytics, Data Science, or Operations role, your HackerRank OA lasts 60 to 90 minutes and focuses on:
2 Advanced SQL Problems (PostgreSQL Syntax): Point-in-time FX currency conversion joins (matching each transaction to the most recent exchange rate timestamp at or before the transaction occurred), 7-day rolling user retention cohorts, and detecting consecutive declined card transactions.
1 to 2 Python / Quantitative Tasks: Pandas/NumPy data wrangling or statistical hypothesis/A-B test calculations.
For UI and mobile roles, the HackerRank test combines 1 to 2 algorithmic coding tasks with asynchronous state management (such as throttling live FX rate WebSocket updates, implementing an LRU cache with TTL expiration, or building a bounded concurrent Promise queue).
Real Interview Questions. Real Candidates. Continuously Updated
Our interview questions come from real job interviews taken by candidates using Linkjob AI. Based on actual interview experiences and continuously updated with new questions
Below are the exact coding and SQL questions from my Revolut HackerRank run and the highest-frequency confirmed problems in Revolut's 2026 question pool, complete with the hidden concurrency and edge-case traps.
This problem—or its twin, the URL Shortener Registry—is the single most famous question in Revolut's engineering hiring pipeline, appearing both on the HackerRank OA and as the foundation of the live coding round.
The Problem Prompt: Design and implement a LoadBalancer class that manages a pool of backend server addresses (strings like "10.0.0.1:8080"). Your implementation must satisfy four strict requirements:
Maximum Capacity (max_instances = 10): The load balancer can store at most max_instances (default 10) unique server addresses. Attempting to register an 11th address must return False (or raise a specific capacity exception, depending on the starter template).
No Duplicate Addresses: Registering an address that is already present in the pool must be rejected (return False), and lookup must run in O(1) average time.
Removal (remove(address)): Removing an existing address frees up capacity for future registrations.
Thread-Safe Round-Robin & Random Selection (get_round_robin() and get_random()): Multiple threads will call get_round_robin(), get_random(), register(), and remove() concurrently. If the pool is empty, raising an exception (IndexError / IllegalStateException) or returning None must be handled cleanly without an IndexOutOfBounds crash when an instance is removed mid-rotation!
The Hidden Trap That Fails Candidates: Many candidates store only a list instances and use list.index() (O(n)) or forget that if rr_index is at 4 and another thread removes the 5th server, self.instances[self.rr_index] throws an IndexError unless you take % len(self.instances) inside the lock right when selecting the element!
My Clean Thread-Safe Python Implementation (O(1) Registration, Removal & Selection):
import random
import threading
class LoadBalancer:
def __init__(self, max_instances: int = 10):
if max_instances <= 0:
raise ValueError("max_instances must be positive")
self.max_instances = max_instances
self._lock = threading.RLock()
self._instances = [] # List for O(1) index access
self._pos_map = {} # Dict {address: index} for O(1) duplicate check & swap-delete
self._rr_counter = 0
def register(self, address: str) -> bool:
if not address:
raise ValueError("Address cannot be empty")
with self._lock:
if address in self._pos_map:
return False
if len(self._instances) >= self.max_instances:
return False
self._pos_map[address] = len(self._instances)
self._instances.append(address)
return True
def remove(self, address: str) -> bool:
with self._lock:
if address not in self._pos_map:
return False
idx_to_remove = self._pos_map.pop(address)
last_address = self._instances.pop()
# Swap-with-last removal keeps deletion O(1)
if idx_to_remove < len(self._instances):
self._instances[idx_to_remove] = last_address
self._pos_map[last_address] = idx_to_remove
return True
def get_round_robin(self) -> str:
with self._lock:
if not self._instances:
raise LookupError("No registered backend instances available")
selected = self._instances[self._rr_counter % len(self._instances)]
self._rr_counter = (self._rr_counter + 1) % len(self._instances)
return selected
def get_random(self) -> str:
with self._lock:
if not self._instances:
raise LookupError("No registered backend instances available")
return random.choice(self._instances)
transfer)Because Revolut processes millions of peer-to-peer and cross-border transfers, testing whether you know how to prevent AB-BA mutex deadlocks in a financial transfer function is a staple of the Backend OA.
The Problem Prompt: Given an Account class with an account_id, a balance (in integer minor units/cents to avoid IEEE-754 floating-point rounding bugs!), and a per-account threading.Lock(), implement transfer(from_account, to_account, amount_cents) -> bool that atomically transfers funds if from_account.balance >= amount_cents and is 100% deadlock-free when Thread 1 calls transfer(acc_A, acc_B, 100) at the exact same millisecond that Thread 2 calls transfer(acc_B, acc_A, 50).
The Classic Deadlock Trap: If transfer(from_acc, to_acc) always locks from_acc.lock first and to_acc.lock second, Thread 1 grabs acc_A.lock while Thread 2 grabs acc_B.lock, and both threads freeze forever waiting for each other!
My Deterministic Lock-Ordering Solution: Always acquire the two account locks in strict ascending order of account_id:
import threading
class Account:
def __init__(self, account_id: int, initial_balance_cents: int):
self.account_id = account_id
self.balance_cents = initial_balance_cents
self.lock = threading.Lock()
def transfer_funds(from_acc: Account, to_acc: Account, amount_cents: int) -> bool:
if amount_cents <= 0:
raise ValueError("Transfer amount must be strictly positive")
if from_acc.account_id == to_acc.account_id:
return True
# Global lock ordering by account_id breaks Circular Wait (Coffman condition #4)
first_lock_acc, second_lock_acc = (
(from_acc, to_acc)
if from_acc.account_id < to_acc.account_id
else (to_acc, from_acc)
)
with first_lock_acc.lock:
with second_lock_acc.lock:
if from_acc.balance_cents < amount_cents:
return False
from_acc.balance_cents -= amount_cents
to_acc.balance_cents += amount_cents
return True
This problem appears across both the Rev-celerator Graduate OA and the Mid/Senior SWE HackerRank pool.
The Problem Prompt: You are given a list of directed currency conversion quotes rates, where each entry (src_curr, dst_curr, rate) means 1 unit of src_curr converts into rate units of dst_curr after fees, plus a list of conversion queries (start_curr, target_curr). For each query, return the maximum amount of target_curr you can obtain starting from 1.0 unit of start_curr (assuming no positive arbitrage cycle exists), rounded to 5 decimal places, or -1.0 if no conversion path exists.
My Clean Max-Heap Dijkstra Solution: By pushing (-current_product, currency) into a min-heap (simulating a max-heap) and only relaxing edges when curr_rate * edge_rate > best_rate[neighbor], you find the optimal multi-hop FX route in O((V + E) log V) time:
import heapq
from collections import defaultdict
def best_fx_conversion_rates(
rates: list[tuple[str, str, float]],
queries: list[tuple[str, str]]
) -> list[float]:
adj = defaultdict(list)
known_currencies = set()
for u, v, r in rates:
adj[u].append((v, r))
known_currencies.add(u)
known_currencies.add(v)
def find_max_rate(start: str, target: str) -> float:
if start not in known_currencies or target not in known_currencies:
return -1.0
if start == target:
return 1.0
best = {start: 1.0}
# Max-heap using negated exchange rate products
pq = [(-1.0, start)]
while pq:
neg_rate, curr = heapq.heappop(pq)
curr_rate = -neg_rate
if curr == target:
return round(curr_rate, 5)
if curr_rate < best.get(curr, 0.0):
continue
for nxt, edge_rate in adj[curr]:
cand_rate = curr_rate * edge_rate
if cand_rate > best.get(nxt, 0.0):
best[nxt] = cand_rate
heapq.heappush(pq, (-cand_rate, nxt))
return -1.0
return [find_max_rate(s, t) for s, t in queries]
deque in O(1) Amortized Time)Revolut's real-time card payment processor flags suspicious velocity spikes when a card is swiped too many times or exceeds a spend ceiling inside a rolling time window.
The Problem Prompt: Given a chronological list of card transactions (tx_id, card_id, timestamp_sec, amount_cents), a rolling window length window_sec, a maximum allowed transaction count max_count, and a maximum allowed cumulative spend max_spend_cents within any [t - window_sec + 1, t] window, return the list of tx_ids that should be declined. Declined transactions do not count toward subsequent velocity windows!
The Trap: Many candidates accidentally push declined transactions into the card's sliding window deque, corrupting every subsequent transaction decision for that card. Only approved transactions should be appended to the active window and added to running_spend!
from collections import defaultdict, deque
def find_declined_transactions(
transactions: list[tuple[str, str, int, int]],
window_sec: int,
max_count: int,
max_spend_cents: int
) -> list[str]:
card_windows = defaultdict(deque) # card_id -> deque of (timestamp_sec, amount_cents)
card_spend = defaultdict(int) # card_id -> running approved spend in current window
declined_tx_ids = []
for tx_id, card_id, ts, amount in transactions:
q = card_windows[card_id]
# Evict approved transactions older than [ts - window_sec + 1, ts]
while q and q[0][0] <= ts - window_sec:
old_ts, old_amount = q.popleft()
card_spend[card_id] -= old_amount
# Check both count velocity and cumulative spend velocity
if len(q) + 1 > max_count or card_spend[card_id] + amount > max_spend_cents:
declined_tx_ids.append(tx_id)
else:
q.append((ts, amount))
card_spend[card_id] += amount
return declined_tx_ids
If your Revolut HackerRank assessment includes SQL (which is mandatory for Data Analysts, Analytics Engineers, Product Analysts, and many Backend tracks), you will almost certainly meet the Point-in-Time FX Rate Join problem.
The Problem Prompt: You have a transactions table (tx_id, user_id, currency, amount, tx_ts) where currency can be 'GBP', 'EUR', 'USD', etc., and an fx_rates table (from_currency, to_currency, rate, rate_ts) containing historical exchange rates into 'GBP'. For each transaction in a non-GBP currency, you must convert amount into GBP using the most recent fx_rates.rate where rate_ts <= tx_ts. Return each user_id and their total transaction volume in GBP (total_gbp_volume), rounded to 2 decimal places, ordered from highest to lowest.
Why a Standard JOIN Fails: Joining purely on t.currency = fx.from_currency AND fx.rate_ts <= t.tx_ts matches every historical FX rate row prior to the transaction, multiplying the user's transaction amount by 50x! You must rank matching FX rates per tx_id using ROW_NUMBER() OVER (PARTITION BY t.tx_id ORDER BY fx.rate_ts DESC) and filter for rn = 1:
WITH matched_fx AS (
SELECT
t.tx_id,
t.user_id,
t.amount,
t.currency,
COALESCE(fx.rate, 1.0) AS applied_rate,
ROW_NUMBER() OVER (
PARTITION BY t.tx_id
ORDER BY fx.rate_ts DESC
) AS rn
FROM transactions t
LEFT JOIN fx_rates fx
ON t.currency = fx.from_currency
AND fx.to_currency = 'GBP'
AND fx.rate_ts <= t.tx_ts
)
SELECT
user_id,
ROUND(
SUM(
CASE
WHEN currency = 'GBP' THEN amount
ELSE amount * applied_rate
END
),
2
) AS total_gbp_volume
FROM matched_fx
WHERE rn = 1
GROUP BY user_id
ORDER BY total_gbp_volume DESC, user_id ASC;
shorten & restore)Right alongside the Load Balancer, Revolut's second most famous OOP design problem on HackerRank is building an in-memory URL Shortener (used internally for revolut.me/ payment links).
The Problem Prompt: Build a UrlShortener class with shorten(long_url: str, custom_alias: str | None = None) -> str and restore(short_url: str) -> str supporting:
Idempotent Long URL Mapping: If long_url has already been shortened with a generated code (and no conflicting custom_alias is requested), return the existing short URL instead of wasting capacity.
Custom Alias Validation: If custom_alias is provided, reject the call (raise ValueError) if that alias is already in use by a different long_url.
Deterministic Base62 Encoding & Thread Safety: Generate compact 6-character Base62 codes safely across concurrent threads up to max_capacity:
import threading
class UrlShortener:
BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
def __init__(self, base_domain: str = "https://rev.me/", max_capacity: int = 10000):
self.base_domain = base_domain
self.max_capacity = max_capacity
self._lock = threading.RLock()
self._code_to_url = {}
self._url_to_code = {}
self._seq_id = 100000
def _encode_base62(self, num: int) -> str:
chars = []
while num > 0:
num, rem = divmod(num, 62)
chars.append(self.BASE62[rem])
return "".join(reversed(chars)).rjust(6, "0")
def shorten(self, long_url: str, custom_alias: str | None = None) -> str:
if not long_url:
raise ValueError("long_url cannot be empty")
with self._lock:
if custom_alias is not None:
if custom_alias in self._code_to_url and self._code_to_url[custom_alias] != long_url:
raise ValueError("Custom alias is already in use")
code = custom_alias
elif long_url in self._url_to_code:
return self.base_domain + self._url_to_code[long_url]
else:
if len(self._code_to_url) >= self.max_capacity:
raise OverflowError("URL Shortener capacity reached")
while True:
self._seq_id += 1
candidate = self._encode_base62(self._seq_id)
if candidate not in self._code_to_url:
code = candidate
break
if code not in self._code_to_url and len(self._code_to_url) >= self.max_capacity:
raise OverflowError("URL Shortener capacity reached")
self._code_to_url[code] = long_url
self._url_to_code[long_url] = code
return self.base_domain + code
def restore(self, short_url: str) -> str:
if not short_url.startswith(self.base_domain):
raise KeyError("Invalid short URL domain")
code = short_url[len(self.base_domain):]
with self._lock:
if code not in self._code_to_url:
raise KeyError("Short URL code not found")
return self._code_to_url[code]
When I reviewed recent candidate reports across Revolut's European, UK, and India hiring loops, these eight additional questions appeared repeatedly:
URL Shortener Service (Base62 + Custom Alias + Capacity Eviction): Design shorten(long_url, custom_alias=None) and restore(short_url) with bidirectional hash maps (long_to_short and short_to_long) so duplicate long URLs reuse existing short keys in O(1) time.
LRU Cache With Time-To-Live (TTL) Expiration: Combine an OrderedDict (or doubly linked list) with per-key expiry_timestamp checks so expired FX quotes are evicted lazily on get() and proactively when capacity is reached.
IBAN & Credit Card Luhn Checksum Validator: Strip spaces, double every second digit from the right, subtract 9 from products > 9, and check if total_sum % 10 == 0.
Minimum Coins / FX Denomination Change (Unbounded Knapsack DP): Compute the minimum number of banknotes required to make target_amount in O(amount * len(coins)) time.
Merge Overlapping Trading / Market Hours: Sort intervals by start_time and merge overlapping ranges in O(n log n) time.
Subarray Sums Divisible by K / Equal Zero-Sum Ledger Slices: Prefix-sum hash map tracking first/total occurrences of running sums in O(n) time.
7-Day Rolling User Retention SQL Query: Self-join or use LEAD(activity_date) OVER (PARTITION BY user_id ORDER BY activity_date) to compute the percentage of newly registered users who completed a second transaction within 7 days.
Consecutive Declined Transactions SQL Query (Gaps and Islands): Use ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY tx_ts) - ROW_NUMBER() OVER (PARTITION BY user_id, status ORDER BY tx_ts) to find users with 3 or more consecutive 'DECLINED' card swipes.
Revolut has a famously data-driven recruiting pipeline, and its engineering reviewers check your HackerRank proctoring telemetry alongside your unit-test results before approving your live coding invite. Here are the four detection layers watching your session.
Even if your Revolut HackerRank invitation does not require webcam access, Copy/Paste Tracking and Keystroke Code Playback are active by default on 100% of HackerRank assessments.
Every time you paste code from your system clipboard into the HackerRank Monaco editor, the platform highlights the pasted block in red on the recruiter's dashboard and logs the event on your Code Playback timeline. When a Revolut engineer replays your session and sees a 55-line LoadBalancer class appear in a single keystroke frame without any incremental typing, method refactoring, or intermediate test runs, your application is rejected on the spot.
blur / visibilitychange)When Tab Proctoring is enabled, the browser listens continuously for DOM focus-loss events (window.onblur and document.visibilitychange). Clicking outside the browser window, switching tabs to look up Python threading.RLock or PostgreSQL window-function syntax, or pressing a global OS shortcut that steals focus from your browser increments your violation counter and records the exact number of seconds you spent away from the test tab.
On webcam-proctored Revolut HackerRank assessments:
Webcam Snapshot AI: The browser captures periodic webcam frames and flags missing faces, extra people in the background, or repeated off-screen eye gaze.
Multiple-Monitor Detection: HackerRank queries your browser's display API to detect secondary monitors. Always physically unplug any external HDMI or DisplayPort monitor before opening your assessment link.
Focus-Stealing Hotkey Traps: Pressing global keyboard shortcuts mid-test to toggle poorly built screen overlays frequently triggers focus-loss logs or exposes the window during screen checks.
HackerRank converts your submitted code into an Abstract Syntax Tree (AST) and compares its structure against public repositories and prior Revolut candidate submissions. Furthermore, HackerRank's Secure Mode embeds invisible Unicode characters or hidden prompt instructions inside the problem statement so candidates who blindly copy-paste the prompt into an external window produce watermarked variable names in their code.
When I took my Revolut HackerRank test, I needed a way to immediately verify the thread-safe O(1) swap-delete logic on the Load Balancer problem and confirm the ROW_NUMBER() point-in-time FX join without switching browser tabs, copying text to my clipboard, or pressing focus-stealing shortcut keys.
That is why I used an AI interview assistant to read the problem constraints directly on screen and show me the clean, production-grade implementation so I could type the code naturally into the HackerRank editor myself. Depending on whether your Revolut link runs in a standard web browser window or under strict webcam proctoring, here is how I set up the two modes.
So here is how it works when your Revolut HackerRank test runs on a standard web page. You can directly use the floating window of the Linkjob AI desktop app right on your monitor.
The moment a coding prompt or SQL schema loads on screen, the floating window analyzes the problem requirements, highlights the concurrency and boundary rules (such as storing money in integer cents and using RLock swap-deletion), and displays the clean solution right next to your code editor—with zero clipboard interaction and zero tab switching.
When using the desktop floating window on a web-based test, there are only two strict rules to watch out for:
Finish all relevant settings before the test starts: Select your preferred programming language (Python 3, Java, Kotlin, Go, TypeScript, or PostgreSQL), position the floating window near your code editor panel, and verify all preferences before you open the HackerRank link. Avoid clicking the app's Settings button during the test so your mouse focus never leaves the browser page.
Do NOT use Cmd + \ or Ctrl + \ to toggle the app during the test: Because HackerRank monitors global keyboard hooks and window focus changes, never press Cmd + \ or Ctrl + \ once your assessment timer starts. Just leave the floating window open in place—all other features work normally.

If you want extra security—or if your Revolut assessment runs under strict webcam Proctor Mode, Secure Mode, or requires a desktop lockdown client—you will need its Dual-Device Mode.
Under Dual-Device Mode, the Linkjob desktop app only runs silently in the background on my laptop with zero visible floating window or on-screen overlay, and all real-time code solutions, unit-test edge cases, and SQL queries display directly on my phone.
Here is why Dual-Device Mode is my favorite setup whenever webcam proctoring is active:
100% Clean Laptop Display: Even if the platform captures full-screen snapshots or scans for active desktop overlays, your computer monitor shows nothing except the official HackerRank browser tab.
Natural Eye Alignment and Spotless Keystroke Playback: By propping my phone right below my laptop webcam, my eyes stay pointed straight toward the camera while I read the solution on my phone and type the code into HackerRank line by line at my normal typing pace—creating a 100% organic Code Playback log with zero clipboard pastes and zero focus switches.
You can choose between the Desktop Floating Window Mode and Dual-Device Mode based on your own scenario and how much extra security you want.
Even when a real-time AI interview assistant gives you the verified algorithm or Load Balancer implementation immediately, remember that Revolut engineers care deeply about production code quality when they inspect your submission. Follow these three habits while typing your solution:
Use Descriptive Domain Variable Names and Helper Methods: Never name your variables d1, q, or arr. Use clean FinTech and systems identifiers like card_windows, max_instances, first_lock_acc, and applied_rate.
Never Use Floating-Point float for Currency Balances When Integer Minor Units Work: Unless the function signature explicitly passes float exchange rates, represent currency balances in integer minor units (amount_cents) or Decimal to show reviewers you understand financial precision.
Click "Run Code" After Each Method Milestone: When building a multi-method class like LoadBalancer, click "Run Code" after implementing register() and remove(), and again after implementing get_round_robin(), so your Code Playback timeline mirrors genuine Test-Driven Development (TDD).
Most Revolut HackerRank assessments last between 60 and 90 minutes and contain 2 to 3 coding or SQL questions. Backend SWE tracks typically combine one multi-method OOP/concurrency design task (like Load Balancer or URL Shortener) with one or two algorithmic problems, while Analytics and Data tracks feature 2 advanced PostgreSQL queries plus 1 to 2 Python/quantitative problems.
Revolut's core backend services are written primarily in Java (17/21) and Kotlin, with Python used heavily across data, ML, and platform tooling, and Go or TypeScript in select teams. On the HackerRank OA, check whether the invitation specifies a mandatory language (some Core Java Backend tracks lock the editor to Java/Kotlin); if multiple languages are open, both Java/Kotlin and Python 3 are great choices as long as you write clean, modular, thread-safe classes.
There are three main reasons candidates fail after passing the sample tests: first, missing thread-safety or capacity boundary checks tested by Revolut's hidden unit-test suite (such as race conditions in round-robin selection or O(n) removal timeouts); second, writing messy, un-modular code with poor naming that fails the human engineering review; and third, triggering a copy-paste or tab-switch flag in HackerRank's proctoring report.
Yes. HackerRank enables Copy/Paste Tracking and Keystroke Code Playback by default on every assessment, and records browser focus loss (blur and visibilitychange) whenever Tab Proctoring is active. Pasting external code blocks or pressing focus-stealing shortcut keys will flag your recruiter report. Never copy-paste code, never press Cmd + \ or Ctrl + \ during a web-based test, or use Dual-Device Mode so all answers display on your phone while you type naturally into the editor.
Once you clear the HackerRank OA, a Revolut recruiter typically follows up within 2 to 5 business days to schedule the Live Coding Interview (60 minutes)—which is a strict, hands-on Test-Driven Development (TDD) session where you share your IDE screen and build a clean, unit-tested service (often extending a Load Balancer, URL Shortener, or Money Transfer Ledger) live in front of a Revolut engineer—followed by a System Design / Architecture Round and a Bar Raiser / Cultural Fit Interview focused on Revolut's values (Get It Done, Deliver WOW, Think Deeper, and Never Settle).
Why People Choose Linkjob AI
Smoother interviews, coding challenges cleared, and job offers landed. See how users describe their experience with Linkjob AI—in their own words.
