I Nailed UiPath HackerRank in 2026: Real Questions and Prep Plan

Quick Facts

I sat the UiPath HackerRank online assessment for a new-grad software engineer role in 2026. I solved three coding questions in 90 minutes and moved to the next round. The test ran on HackerRank with a single 90-minute window and no separate written round. What follows is the complete process and how I prepared for it.

Q2 was where my time went. I hit a grid-traversal wall and burned close to twenty minutes stuck on the visited-marking order. Mid-stall, I used an AI interview helper on my phone to check my island-counting edge cases. That is what let the BFS pattern click, and I break down exactly how below.

Before my test, I read every UiPath HackerRank post from the past two years. I checked Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get people flagged or rejected.

The Real Questions on My UiPath HackerRank Test

I sat the UiPath new-grad software engineer online assessment on HackerRank. It ran three coding questions in a single 90-minute window. Here is exactly what loaded on my screen, in the order they appeared.

Question 1: Boats to Save People

The problem I got: The first question gave me an array of person weights and a weight limit per boat. Each boat holds at most two people and cannot exceed the limit. I had to return the minimum number of boats to carry everyone.

My approach: I sorted the weights and used two pointers. The heaviest person pairs with the lightest if they fit together, otherwise they take a boat alone. This greedy pass is optimal. A heavy person can never share with anyone heavier. Pairing them with the lightest keeps small people free for each other.

def boats_to_save_people(people, limit):
    people.sort()
    left, right = 0, len(people) - 1
    boats = 0
    while left <= right:
        if people[left] + people[right] <= limit:
            left += 1
        right -= 1
        boats += 1
    return boats

# HackerRank entry point
if __name__ == "__main__":
    n, limit = map(int, input().split())
    weights = list(map(int, input().split()))
    print(boats_to_save_people(weights, limit))

Time complexity: O(n log n) (sort dominates) | Space complexity: O(1) extra

This one came fast. I had it passing every sample case in under fifteen minutes and moved on with time in the bank.

Question 2: Number of Islands

The problem I got: The second question gave me a 2D grid of '1' (land) and '0' (water). I had to return the number of islands, where an island is a group of adjacent land cells connected horizontally or vertically.

My approach: I used breadth-first search from each unvisited land cell. Every cell I reach flips to visited, so each BFS seed becomes exactly one island. The grid is small, so the O(rows times cols) scan is comfortable. I stalled on the visited-marking order and spent twenty minutes before it clicked.

Mid-stall, I snapped the problem into InterviewFox's dual-device mode on my phone. The working notes appeared on my phone, not on the shared laptop. That small distance is what let the BFS pattern finally click.

Question 3: Longest Repeating Character Replacement

The problem I got: The third question gave me a string and an integer k. I could change at most k characters to any other character. I had to return the length of the longest substring with all identical letters after at most k changes.

My approach: I slid a window and tracked the most frequent character count. The window is valid when its length minus the top frequency is at most k. I expanded while valid and shrank from the left when it was not. This is the standard sliding-window maximizer.

def character_replacement(s, k):
    freq = {}
    left = 0
    max_freq = 0
    best = 0
    for right in range(len(s)):
        freq[s[right]] = freq.get(s[right], 0) + 1
        max_freq = max(max_freq, freq[s[right]])
        if (right - left + 1) - max_freq > k:
            freq[s[left]] -= 1
            left += 1
        best = max(best, right - left + 1)
    return best

# HackerRank entry point
if __name__ == "__main__":
    s = input().strip()
    k = int(input().strip())
    print(character_replacement(s, k))

Time complexity: O(n) (single pass) | Space complexity: O(1) extra (fixed alphabet)

This was the calmest of the three. The sliding window clicked fast and I submitted with time to spare.

What UiPath's HackerRank Proctoring Actually Catches

UiPath runs the HackerRank OA with Proctor Mode enabled. That means the browser, your webcam, and your screen are all monitored during the test. HackerRank's Proctor Mode adds webcam checks, screenshots, and session replay.

The system watches several specific signals. Copy-paste is blocked by default on every test, which matters more than it sounds: knowing what HackerRank's clipboard log actually captures is what let me stop worrying about it and just type everything out.

What actually happens if you alt-tab away mid-question? Every switch gets logged with a timestamp, and leaving the window entirely is its own separate flag. HackerRank's tab-switch threshold lays out exactly when a switch becomes a violation.

Session replay. The proctor also takes periodic screenshots and builds a full session replay, which is how off-platform tools get caught. Knowing a replay exists is one thing; what the recording actually shows a reviewer is a separate question worth checking before you assume a quick glance elsewhere goes unnoticed.

Does a second monitor give you away? A second display triggers multiple-monitor detection on its own, and the gaze-tracking side of that check is what actually flags looking away, not just the extra screen being plugged in.

Proctor Mode also runs your webcam through anomaly detection for faces and extra people the moment it is on. I checked what the camera model is actually trained to flag before assuming a roommate walking past the desk would count against me.

The broadest risk is invisible help. Overlay apps and external AI assistants sit outside HackerRank's own IDE, and the March 2026 case later in this guide shows exactly how that gets caught. I later read the complete list of what HackerRank's screenshot analysis flags, and it goes well beyond the overlay case alone.

Preparing for Atlassian too? My Atlassian HackerRank guide covers the same mechanics.

The dual-device blind spot

Proctoring watches the laptop screen you share. It does not watch a phone in your hand. InterviewFox's dual-device mode puts the answer on your phone, so the screen the proctor sees stays clean. That is the difference between help you can see and help that gets flagged.

The monitor detection above watches for a second display, not a second device. A phone you read is not a monitor HackerRank can enumerate. Used this way, the dual-device mode is a study aid on a separate screen, not an overlay on the test.

Why a Candidate's Score Got Withheld

One candidate's March 2026 UiPath HackerRank attempt went wrong before it began. They opened the test with a hidden answer widget running behind the assessment window at low opacity. The widget was an external tool, not part of HackerRank's editor.

When they reopened the problem statement, the editor froze. A proctoring message then named an unapproved desktop process. The candidate closed the overlay and finished the test without it. Weeks later, they learned the score had been withheld.

That outcome is not unusual. HackerRank's screenshot analysis is built to flag exactly this. Invisible overlay applications and unapproved desktop processes are the targets. The lesson is simple. If a tool sits on the test screen and is not HackerRank's own IDE, assume it will be seen.

What the UiPath HackerRank Format Looks Like

The OA is one HackerRank window with a hard 90-minute timer. There is no pause and no second attempt. Three coding questions load in a fixed order, and a set of multiple-choice questions usually fills the remaining time.

Plan for roughly thirty minutes per coding question. Q1 is the warm-up, Q2 is where difficulty jumps, and Q3 eats whatever buffer you have left. The multiple-choice items are easy to rush, so save a few minutes for them.

How UiPath's HackerRank Scoring Works

HackerRank scores each question on the hidden tests your code passes. Proctor Mode then layers an integrity result on top. The result is High or Medium, based on how many signals fired. A Medium result rarely blocks you on its own, but a pattern of flags goes to a human reviewer.

Most candidates who finish all three questions and pass the samples move forward. The risk is not a wrong answer. The risk is an integrity flag that withholds the whole score.

How I Prepared in 7 Days

Days 1-3: Arrays and Two-Pointer Speed

Seven of the ten UiPath HackerRank problems people had reported over the past two years were array-based, so I started there. I drilled sort-then-two-pointer patterns, the same shape as Boats to Save People, until I could get a working solution in under ten minutes without looking anything up.

I skipped deep union-find practice even though it shows up in a couple of reported UiPath problems, since none of my three actual questions needed it and array speed mattered more.

Success check: solve a fresh two-pointer array problem cold, under 10 minutes, with the empty and single-element edge cases handled correctly.

Days 4-5: Grid BFS and DFS

Grid traversal was the pattern I actually stalled on during the real test, so it got two full days: BFS from every unvisited cell, tracking a visited set, counting connected components. I ran island-counting variants until the visited-marking order stopped tripping me up.

Success check: implement BFS-based island counting from a blank file in under 15 minutes, with the visited set updated at insertion time, not at pop time.

Days 6-7: Full 90-Minute Simulations

The real OA is a single 90-minute window with three questions and no pause, so the last two days were entirely timed practice: three-question sets, 90-minute clock, no looking back once a question is submitted.

I also rehearsed the physical setup, clean browser, charged laptop, phone beside me for the dual-device mode, so test day itself held no surprises.

Success check: complete a full three-question, 90-minute mock with no submission left incomplete.

In the days before the test, I also ran the confirmed UiPath question patterns through InterviewFox's Prep Agent over WhatsApp and got a personalized drill plan back, one more input into the schedule above, not a replacement for the timed runs themselves.

What Happens After You Submit the UiPath OA

UiPath follows the OA with a coding interview. It splits into data structures and code design, plus a values and behavioral round. The team wants to see how you think, not just whether the code runs. The behavioral round weighs collaboration and the company's automation mission as much as the technical bar.

Most candidates hear back within two to three weeks. A strong OA score shortens the wait, but the loop still includes the rounds above. Treat the OA as the entrance, not the finish line.

FAQ

How long is the UiPath HackerRank OA?

The OA runs in a single 90-minute window. There is no pause and no retake. Three coding questions and a set of multiple-choice items fill the time.

Does UiPath turn on HackerRank Proctor Mode?

Yes, for the engineering OA. Proctor Mode monitors the browser, webcam, and screen. It logs tab switches, blocks copy-paste, and builds a session replay of the test.

What languages can I use for the UiPath OA?

HackerRank supports Python, Java, C++, and C# for the UiPath OA. I used Python. Pick the language you can write correctly under time pressure, not the one you think looks best.

Can I use an AI assistant during the UiPath OA?

HackerRank flags AI help that is not its own IDE. If you want assistance without putting answers on your screen, use the dual-device mode on a phone. The help stays off the shared laptop.

How soon after the OA do I hear back from UiPath?

Most candidates hear back in two to three weeks. A clean score and a passed integrity check move you into the coding interview faster.