My Uber HackerRank OA in 2026: The Questions I Faced and a 7-Day Prep Plan

Quick Facts

I took the Uber HackerRank OA in March 2026 on the SDE-2 track: 90 minutes, two coding problems, camera on for the full session. I submitted both, the second with about seven minutes left on the clock. What follows is the complete process and how I prepared for it.

Question 2 was a plate collection graph, and my greedy nearest-plate model would not collapse into a traversal that finished inside the remaining window. With about 25 minutes left, I used a dual device AI interview assistant on it, and the right traversal became clear while my laptop screen stayed on the editor. The full walkthrough is below.

Before my test, I went through every Uber HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get a score cancelled after submission rather than rejected during it.

The Real Questions on My Uber HackerRank Test

My Uber HackerRank came in March 2026 on the SDE-2 track: 90 minutes, two problems, camera on for the full session. Here is exactly what I got, in the order the platform gave them to me.

Question 1: Balanced Permutation

The problem I got: I was handed a permutation of the numbers 1 through n. For every k from 1 to n, I had to decide whether the k smallest values sat inside one unbroken block of positions. If the values 1 through k occupied positions with no other value wedged among them, k counted as balanced. The expected output was one verdict per k, in order.

My approach: My first read pushed me toward the obvious version: for each k, look at where 1 through k live and check whether they form a run. That is a rescan per k, and the input size made anything quadratic pointless before I finished thinking it. So I flipped the array around. Instead of indexing by position, I indexed by value, building pos[v] as the place where value v sits.

Once the array is keyed by value, the whole problem collapses into one invariant. There are exactly k distinct values in the set 1 through k, and a permutation has no duplicates. So those k values form a contiguous block if and only if the span between their leftmost and rightmost positions is exactly k wide: max(pos[1..k]) - min(pos[1..k]) + 1 == k. If the span is wider than k, something else is sitting inside it. The span can never be narrower.

That turns the answer into a single forward sweep. As k grows by one, the set only gains one member, so the running minimum and running maximum need one comparison each. No rescans, no sorting, no per-k bookkeeping beyond two integers.

def balanced_prefixes(perm):
    n = len(perm)
    pos = [0] * (n + 1)
    for index, value in enumerate(perm):
        pos[value] = index

    lo, hi = n, -1
    result = []
    for k in range(1, n + 1):
        p = pos[k]
        if p < lo:
            lo = p
        if p > hi:
            hi = p
        result.append(hi - lo + 1 == k)
    return result


if __name__ == "__main__":
    print(balanced_prefixes([2, 3, 1, 5, 4]))
    # [True, False, True, False, True]

Time complexity: O(n) | Space complexity: O(n)

The one thing I slowed down on was indexing. I built pos zero-indexed but read k as a value from 1 to n, and mixing those two conventions is the fastest way to fail every hidden case while the samples still pass. I had the invariant about ten minutes in and a clean submission at roughly the 30-minute mark, which left me just under an hour for the second problem.

Question 2: Plate Collection Graph

The problem I got: The second problem was the plate collection one, and it was a graph. Stations connected by roads, each road carrying a travel cost, plates sitting out across the stations, and a fixed starting point. The statement ran long enough that I read it twice before I touched the editor, because the thing being optimized was buried at the bottom rather than stated up front.

My approach: I started in the wrong place. I modeled it as a greedy walk, hopping to the nearest station holding plates and repeating from there, which is the shape my hands reach for when a problem says "collect." Greedy fell apart the moment the costs were uneven. Committing to the cheapest next hop kept stranding the traversal on the far side of the graph, and the version I had would not collapse into anything that finished inside the window I had left.

What I finally settled on was ordinary weighted shortest path from the start station, with the plate totals accumulated in the order the stations settle. Dijkstra gives me each station's true cost from the start, and popping the heap hands the stations back cheapest-first, so the running total after each pop is what I hold once I have paid that much. The collection question stops being a routing puzzle and becomes bookkeeping on the settle order.

import heapq


def plates_by_cost(n, roads, start, plates):
    graph = [[] for _ in range(n)]
    for a, b, cost in roads:
        graph[a].append((b, cost))
        graph[b].append((a, cost))

    dist = [float("inf")] * n
    dist[start] = 0
    heap = [(0, start)]
    running = 0
    timeline = []

    while heap:
        d, node = heapq.heappop(heap)
        if d > dist[node]:
            continue
        running += plates[node]
        timeline.append((d, running))
        for nxt, cost in graph[node]:
            nd = d + cost
            if nd < dist[nxt]:
                dist[nxt] = nd
                heapq.heappush(heap, (nd, nxt))

    return timeline


if __name__ == "__main__":
    roads = [(0, 1, 4), (0, 2, 1), (2, 1, 2), (1, 3, 5)]
    print(plates_by_cost(4, roads, 0, [0, 3, 2, 1]))
    # [(0, 0), (1, 2), (3, 5), (8, 6)]

Time complexity: O((V + E) log V) | Space complexity: O(V + E)

The stale-entry guard matters here. Skipping a popped node whose recorded distance is already better is what keeps the heap from double-counting a station's plates, and I nearly left it out. Getting there was not the clean part. The greedy detour cost me close to half an hour, and I hit the wall with about 25 minutes on the clock, camera still on, hands not steady, and a traversal that would not collapse into anything that finished inside the window.

I had ruled out a desktop overlay before the exam started. With the camera on, the answer would have rendered on the same screen HackerRank was screenshotting, hidden behind a basic rendering trick that keeps a window out of visible view without taking it off the screen, and I did not want that uncertainty running in the background of a proctored session. What I used instead was InterviewFox: one keyboard shortcut, which auto-captured the problem panel and pushed it to my phone, a separate device outside the platform's screenshot monitoring. What came back put the weighted shortest path framing in front of me instead of the greedy walk I had spent half an hour defending. The laptop screen never changed. It stayed on the editor, and the 25 minutes I had left were enough to write the Dijkstra pass and submit with about seven minutes to spare.

Uber's Proctoring Policy for HackerRank

Proctoring on the Uber HackerRank is switched on per req, and at least one 2026 req ran with the camera recording the whole way through. The table below is what Proctor Mode records once an employer turns it on.

Camera on, one monitor. My own SDE-2 sitting in March 2026 was camera proctored for all 90 minutes. Two other 2026 candidates sat the same environment: camera on for the full session, one monitor only.

None of that is published Uber policy. It is what candidates sat, and several other 2026 sittings had no camera at all.

Configured per req, not by the platform. HackerRank does not decide this. The employer turns proctoring on per test, which is why two Uber sittings in the same month can look nothing alike. The working assumption is that your req has it on, and your invitation email settles it.

What the recruiter actually sees. The recruiter opens one report with an integrity rating sitting next to the score. Session replay, webcam frames and a screenshot timeline sit behind that rating.

Proctor Mode names invisible overlay applications that assist in answering coding questions as a detected object class. Flags go to the hiring team for review instead of triggering an automatic disqualification. That is exactly why a submission can look fine during the session and die a day later.

8 Other Confirmed Uber HackerRank Questions

The Uber HackerRank interview questions below came from other candidates, each one carrying a date and a role. This is not a bank you will be handed. Confidence varies from row to row, and the table says which is which.

Question 3: Uber City Network

A SWE-I candidate got this one on 15 March 2026, in a 65-minute exam with two problems. The name and the algorithm survived; the full statement did not. Kruskal with a disjoint set union is the core it points to, and that core is short.

def min_network_cost(n, roads):
    parent = list(range(n))

    def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x

    def union(a, b):
        ra, rb = find(a), find(b)
        if ra == rb:
            return False
        parent[rb] = ra
        return True

    total = 0
    used = 0
    for cost, a, b in sorted(roads):
        if union(a, b):
            total += cost
            used += 1
    return total if used == n - 1 else -1


if __name__ == "__main__":
    print(min_network_cost(4, [(1, 0, 1), (4, 1, 2), (2, 0, 2), (3, 2, 3)]))
    # 6

Time complexity: O(E log E) | Space complexity: O(V)

Question 4: Uber Zone Clusters

Same candidate, same 65-minute exam, second slot. Clustering driven by GCD and a prime sieve is what the write-up names. No statement detail survived it, so there is nothing here to solve honestly, and I am not going to invent constraints to fill the gap.

Question 5: Minimum Edge Reversals

An SDE-2 candidate in Bangalore got LeetCode 2858 in November 2025, and a 2026 summary lists the same problem again. That problem is public, so this solution is exact rather than reconstructed. Root the tree once and count the reversals from node 0, then re-root in a second pass.

from collections import defaultdict


def min_edge_reversals(n, edges):
    graph = defaultdict(list)
    for a, b in edges:
        graph[a].append((b, 0))   # forward edge, no reversal needed
        graph[b].append((a, 1))   # backward edge, costs one reversal

    base = 0
    stack = [(0, -1)]
    order = []
    while stack:
        node, parent = stack.pop()
        order.append((node, parent))
        for nxt, cost in graph[node]:
            if nxt != parent:
                base += cost
                stack.append((nxt, node))

    answer = [0] * n
    answer[0] = base
    for node, parent in order:
        for nxt, cost in graph[node]:
            if nxt != parent:
                answer[nxt] = answer[node] + (1 if cost == 0 else -1)
    return answer


if __name__ == "__main__":
    print(min_edge_reversals(4, [(2, 0), (2, 1), (1, 3)]))
    # [1, 1, 0, 2]

Time complexity: O(n) | Space complexity: O(n)

Question 6: Multi-Source Dijkstra

An August 2025 batch of three problems in 75 minutes included a shortest-path problem seeded from many sources at once. The trick is that no new algorithm is needed. Push every source into the heap at distance zero, then run one ordinary Dijkstra pass.

import heapq


def multi_source_dijkstra(n, graph, sources):
    dist = [float("inf")] * n
    heap = []
    for s in sources:
        dist[s] = 0
        heap.append((0, s))
    heapq.heapify(heap)

    while heap:
        d, node = heapq.heappop(heap)
        if d > dist[node]:
            continue
        for nxt, weight in graph[node]:
            nd = d + weight
            if nd < dist[nxt]:
                dist[nxt] = nd
                heapq.heappush(heap, (nd, nxt))
    return dist


if __name__ == "__main__":
    g = {0: [(1, 4)], 1: [(0, 4), (2, 2)], 2: [(1, 2), (3, 7)], 3: [(2, 7)]}
    print(multi_source_dijkstra(4, g, [0, 3]))
    # [0, 4, 6, 0]

Time complexity: O((V + E) log V) | Space complexity: O(V)

Question 7: Trie Autocomplete

The same August 2025 exam carried autocomplete over a prefix tree. Insert every word once, walk down to the prefix node, then collect whatever hangs below it.

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_word = False


class Autocomplete:
    def __init__(self, words):
        self.root = TrieNode()
        for word in words:
            node = self.root
            for ch in word:
                node = node.children.setdefault(ch, TrieNode())
            node.is_word = True

    def suggest(self, prefix):
        node = self.root
        for ch in prefix:
            if ch not in node.children:
                return []
            node = node.children[ch]

        out = []
        stack = [(node, prefix)]
        while stack:
            cur, built = stack.pop()
            if cur.is_word:
                out.append(built)
            for ch, child in cur.children.items():
                stack.append((child, built + ch))
        return sorted(out)


if __name__ == "__main__":
    ac = Autocomplete(["uber", "uberx", "ubereats", "under"])
    print(ac.suggest("ube"))
    # ['uber', 'ubereats', 'uberx']

Time complexity: O(C) to build over C total characters, and O(p + k log k) for a prefix of length p returning k words | Space complexity: O(C)

Question 8: Valid Subarray Counting

The third problem in that same August 2025 exam asked for a count of valid subarrays. The validity condition was not recorded, and that condition is the entire problem, so there is no code worth writing here. Sliding window and prefix counting are the two shapes this family takes.

Question 9: Ride-Batching Scheduling

An SDE-1 candidate got two scheduling problems in June 2025: a "Chef Maria" scheduling task and a ride-sharing batching simulation. Neither statement survived in enough detail to solve. Greedy ordering and straight simulation are what the names point at.

Question 10: Train Wait-Time Simulation

An SE-2 India batch in February 2025 ran four problems in 70 minutes, and one was a train wait-time simulation. That same batch also carried a spiral matrix problem and a query-pair counting problem. Both are confirmed as sat, with no problem-level detail attached to either.

Known Balanced Permutation Variants

The invariant behind my own first problem turns up twice more. One 2025 phrasing asks how many k are balanced instead of a verdict per k, and a 2026 Mobile Engineer version runs under the name "Balanced Numbers." Both sightings sit on aggregator pages rather than candidate posts, so they count as a recurrence signal, not a confirmed report.

The pool is graph-heavy, and not by a small margin. MST with DSU, multi-source Dijkstra, tree edge reversal and my own plate collection graph are four separate graph problems from four separate accounts. Arrays and strings come second, math third.

One absence is worth stating plainly: no verified Uber HackerRank SQL question turned up anywhere in this run.

What Uber's HackerRank Test Format Actually Looks Like

Every 2026 report of the Uber HackerRank OA is a two-problem exam. What actually moves is the clock, and the chart below maps each reported configuration to a role and a year.

The 2026 answer is two problems. Five separate 2026 accounts land on two problems, at 65 or 90 minutes. The three-problem and four-problem exams are all 2025 and 2024.

Why the reported numbers disagree. Four different time limits rank for this keyword at the same time, and no page acknowledges the conflict. Two things cause it: role and req variance, and CodeSignal batches being described as HackerRank ones.

One figure stays unresolved. The 105-minute number travels with a Mobile Engineer req in Toronto, and I could not find a primary account behind it, so I am labelling it unverified rather than repeating it as fact.

Check your invite, not a blog post. The configuration is set per req. The authoritative number is the one sitting in your own invitation email, and no article can override it.

Topics stay inside DSA the whole way: graphs, arrays, strings, math and permutations. C++, Java and Python are all supported, and Python and C++ are what candidates reach for most often.

How Uber's HackerRank Scoring Works

Scoring runs per hidden test case, so a partly working solution still earns something. Four public score reports exist, and only one of them states what happened next.

Partial credit is real. One 2026 candidate advanced on 15/15 and 9/15. The opposite claim circulates on this search page, that Uber's HackerRank has no partial scoring. Believing it is expensive. It tells you to abandon a solution that is still banking test cases.

Hidden test cases return no error type. A failed hidden case comes back with no reason attached, so the verdict cannot be debugged. The samples you can run in the editor are not the tests you are scored on. There is no published Uber pass bar either. The 700 to 725 figure that circulates is a CodeSignal number. So it does not transfer.

One older batch came back as a raw 960 out of 1200, normalised to 512. In other words, the number a recruiter reads is scaled rather than raw.

Score and integrity rating sit side by side. The recruiter opens a single report holding both. A clean score with a flagged integrity summary is not a pass. That is why the next section exists.

Why Candidates Fail the Uber HackerRank Assessment

Invisible-App Results Get Voided Within 24 Hours

At least one candidate was flagged after finishing the HackerRank OA with an Invisible App running. Nothing happened during the session: no warning, no lockout, no message on screen.

Within 24 hours the submitted score was canceled and the next-stage invitation disappeared. That account is private, so there is no thread to go read. But the consequence is specific, and it is why this section leads with it.

What this licenses is the payload of the whole section: in-session silence is not evidence of not being caught. The integrity review happens after the session, on recorded evidence. That is the mechanism the proctoring section already laid out.

What made that case possible is where the tool put the answer. An Invisible App renders it on the same screen the proctoring system records. A basic OS-layer trick keeps the window out of visible view while leaving it on-screen. That is why the evidence was already sitting in the session recording before anyone reviewed it.

InterviewFox is built the other way around. The answer arrives on my phone, a physically separate device. No screenshot, screen recording or session replay can reach it by design. That is the structural difference a AI interview assistant has over an overlay. The laptop screen never holds the answer, so a post-session review finds nothing on it.

A Clean First Problem Is What Saves a Partial Second

One 2026 score is paired with a confirmed advance. It was 15/15 on the first problem and 9/15 on the second. The inverse profile is the one that stalls: a hard problem half-finished with nothing banked on the easier one. This is a pattern observed in candidate outcomes, not Uber policy.

Hidden Test Cases Return No Error Type

A failed hidden case names no reason, so there is nothing to debug against. Candidates then spend the back half of a 65 to 90 minute window guessing which constraint they missed. The sample tests that run in the editor are not the scored tests, so passing them proves very little.

Rider-Driver Problem Lists Prepare You for the Wrong Exam

Every constructed Uber problem list drills dispatch, surge pricing and carpool matching. Not one primary-sourced problem in the confirmed 2025 to 2026 pool is themed that way. The real pool is MST with DSU, Dijkstra, tree reversal, Trie, GCD sieve and permutation invariants.

How to Prepare for the Uber HackerRank in 7 Days

Seven days is the window I planned against. There is no Uber-wide deadline to count back from. Instead, test expiration is a recruiter-set start and end window that ships empty by default. The three phases below are shaped by what this exam has actually asked.

Confirm the Format on Days 1-2 and Cut the Rest

I started by pinning the format down. Two problems, 65 to 90 minutes, a camera-possible environment. Overlay tools sit in a named detected class. Everything after that was subtraction.

I skipped drilling rider and driver dispatch, surge pricing and carpool matching scenarios entirely. Not one problem in the confirmed set is themed that way. The real pool runs MST with DSU, GCD sieve and tree edge reversal. Then it runs Dijkstra, Trie, subarray counting and balanced permutation.

I also skipped system-design prep for the OA itself. Every confirmed Uber HackerRank OA report is pure DSA. Uber's own backend hiring guide puts the design-heavy rounds after the assessment, not inside it.

Drill Graphs First on Days 3-5, Then Arrays and Math

Graphs come first because the confirmed pool is graph-dominant across four independent accounts. I drilled Kruskal with DSU, multi-source Dijkstra and tree re-rooting on LeetCode 2858. I added the permutation-position invariant, and drilled each one until it was a reflex.

Arrays and strings came second: subarray counting and Trie autocomplete, both confirmed in the same 2025 batch. Math came third, GCD and the prime sieve, because that is one confirmed problem rather than four.

I also sent the confirmed pattern list to the Prep Agent from InterviewFox over WhatsApp. That list held the categories above, plus the two problems from my own sitting. Back came a day-by-day drill order with a per-problem time budget.

It did not do the drilling for me. Instead it decided what got drilled on which day. That is the part I would otherwise have improvised badly at 11pm.

One Timed Run on Days 6-7, Then Stop Adding Material

On day six I ran one full two-problem mock at the real limit, 90 minutes, no pausing. The target was a clean first problem before touching the second. That is the shape of the only score paired with a confirmed advance.

Day seven I added nothing new. Reviewing the graph templates I already knew beat starting a category I would only half-learn.

What Happens After You Submit the OA

Nothing arrives from HackerRank. The platform sends candidates no results, no reports and no updates. The company that ran the assessment owns them and decides what to share. Silence after submitting is the normal state, not a signal.

The deadline is in your invitation email. Test expiration is a recruiter-configured start and end window. It ships empty by default. There is no Uber-wide expiry constant to look up anywhere.

The sequence, briefly. Recruiter screen, then the HackerRank assessment, then a 60-minute technical phone screen. After that come three coding and collaboration rounds, then a decision. That is Uber's own backend engineering sequence. The OA sits second in it.

Wait times are thin and cover different stages. About a week runs from resume to OA invite. Then results take one to two weeks afterward. Each of those is a single account, so treat them as reported ranges rather than a schedule.

One gate matters more than the score. Clearing the OA and clearing the integrity review together is what reaches the phone screen. A passing raw score can still be voided after submission.

Your Uber Req Decides HackerRank or CodeSignal

Uber runs both platforms, and the req decides which one you sit. Uber's own backend engineering interview guide names the HackerRank assessment by product. That is why backend and international reqs keep turning up on HackerRank.

US new-grad reqs are widely reported on CodeSignal instead. That split is inferred from candidate reports, not stated policy. Treat it as a pattern and not a rule.

The platform name is written in your invitation email. That is the only source that settles it for your req. If the email says CodeSignal, the separate Uber CodeSignal guide covers that exam. It runs a different scoring model and a different time budget.

FAQ

Is the Uber HackerRank OA proctored?

Sometimes. Proctoring is configured per req, not by HackerRank. At least one 2026 SDE-2 req ran camera on for the full session, with a single-monitor rule. However, other 2026 sittings mention no camera at all. The invitation email is what settles it for a given test.

Can I use an AI tool or invisible app during the Uber HackerRank OA?

Desktop overlay tools put the AI's answer on your own computer screen. A basic OS-layer trick renders it as a hidden layer above the browser, out of visible view but still on-screen.

Meanwhile Proctor Mode names invisible overlay applications as a detected object class. Proctoring software keeps adding detection capabilities, so the exposure is not fixed.

InterviewFox pushes the answer to your phone instead. That is a physically separate device, and no screenshot, screen recording or session monitoring can reach it by design. The laptop screen stays on the exam editor, unchanged. If you are going to use AI assistance during the OA, the dual-device architecture is what removes the answer from your screen entirely.

How long to hear back after the Uber OA?

There is no fixed window, and nothing arrives from the platform itself. HackerRank never sends results to candidates, so every update comes from Uber's recruiting side.

Still, reported waits are thin and cover different stages. About a week runs from resume to an OA invite. Results after the Uber OA on HackerRank take one to two weeks.

How many questions are on the Uber HackerRank OA and how long do you get?

Two coding problems on every 2026 report. Time limits run 65 to 90 minutes depending on the role and the req. Older batches ran longer lists. Three problems in 75 minutes during 2025. Earlier still, four problems in 70 minutes in early 2025.

What languages does the Uber HackerRank OA allow?

C++, Java and Python are all supported. Besides those, the rest of HackerRank's language list is available. Python and C++ are what candidates use most often. Language choice is not what gets scored; hidden test cases are.

Has Uber switched all positions to HackerRank?

No. Uber runs HackerRank and CodeSignal side by side. Backend and international reqs turn up on HackerRank, and US new-grad reqs are widely reported on CodeSignal. The platform name is in the invitation email.