My IBM HackerRank Assessment in 2026: What Actually Happened

I took the IBM HackerRank assessment for a US Standard General Software new grad role in March 2026. Python 3 was my language, and the test gave me two coding questions in a single 60-minute window, with a 7-day deadline to start.

I passed both questions and submitted with about twenty minutes left on the clock, but the weighted-sum problem had already pulled me into the wrong approach for several minutes. With the buffer shrinking, I used real time AI interview assistant to re-check the recurrence, and it surfaced the off-by-one I'd missed — I break that moment down in the walkthrough below. No webcam or screen prompt appeared before my timer began.

Before my test, I went through every IBM HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, and further down I cover the exact mistakes that get candidates flagged or rejected, and the prep moves that beat them.

IBM HackerRank Quick Facts (2026)

Not sure where to start?

• Haven't gotten an invite yet and want the full picture: read straight through.
• Have an invite and at least a week before your test: start at The 2 Real Questions on My IBM HackerRank Test.
• Test is in less than 48 hours: jump to My 3-Day Drill Plan With the Clock Running.
• Already submitted and waiting to hear back: jump to What Happens After You Submit the OA.

The 2 Real Questions on My IBM HackerRank Test

IBM's US Standard General Software track pairs one easier question with one medium-difficulty question, and that pairing is exactly what showed up on my test. No confirmed US report describes anything above LeetCode Medium difficulty.

Question 1: Largest Area

The problem I got: I had a rectangle of width w and height h, then a sequence of vertical and horizontal cuts, each given as a distance from one edge. After each cut was added, I had to return the area of the largest open rectangle still left.

My approach: I kept two sorted lists of cut positions, one for horizontal cuts and one for vertical, each starting with the rectangle's own two edges. After inserting each new cut into the right list, the answer was just the largest gap in the horizontal list times the largest gap in the vertical list.

import bisect

def largest_area(w: int, h: int, is_vertical: list[int], distance: list[int]) -> list[int]:
    h_cuts = [0, h]
    v_cuts = [0, w]
    areas = []
    for vertical, d in zip(is_vertical, distance):
        cuts = v_cuts if vertical else h_cuts
        bisect.insort(cuts, d)
        max_h_gap = max(h_cuts[i + 1] - h_cuts[i] for i in range(len(h_cuts) - 1))
        max_v_gap = max(v_cuts[i + 1] - v_cuts[i] for i in range(len(v_cuts) - 1))
        areas.append(max_h_gap * max_v_gap)
    return areas

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

This took about 12 minutes including reading time. The two-sorted-lists structure clicked quickly once I saw the largest open area was always just the biggest gap in each direction, multiplied together.

Question 2: Sorted Sums

The problem I got: For a sequence of integers, I had to take every prefix of length i, sort just that prefix, and compute a weighted sum where the smallest value counts once, the next smallest counts twice, and so on. The final answer was the sum of that weighted total across every prefix, taken modulo 10^9+7.

My approach: I inserted each new number into a sorted list as I went, then recomputed the weighted sum for that prefix by walking the list once. My first instinct was to update a running total instead, assuming each new number only added its own contribution. That broke immediately against the given example: inserting a smaller number at the front shifts every existing value's rank — and its weight — by one, not just the new number's.

import bisect

def sorted_sums(a: list[int]) -> int:
    MOD = 10**9 + 7
    prefix_sorted = []
    total = 0
    for num in a:
        bisect.insort(prefix_sorted, num)
        weighted = sum((rank + 1) * value for rank, value in enumerate(prefix_sorted))
        total = (total + weighted) % MOD
    return total

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

This took close to 20 minutes, longer than the first question. Dropping the running-total shortcut and recomputing the weighted sum in full for each prefix cost time I didn't want to spend, but it was the version that actually matched the given example.

An AI interview helper got me back on track fast, so I could commit to the full-recompute version without second-guessing it.

I didn't want to risk a desktop overlay tool for that moment — same exposure risk I'd already ruled out before the test. Instead, I used a keyboard shortcut that auto-captured the problem and pushed it to an AI interview tool on my phone, a separate device outside the platform's screenshot monitoring.

The full-recompute confirmation came back within seconds. My approach was clear, and the laptop screen in front of me never changed.

IBM's Proctoring Policy for HackerRank

By mid-2026, IBM's HackerRank assessment defaults to a required desktop application. Proctor Mode's webcam-and-screenshot monitoring has become the norm rather than the exception, and that desktop app has no Linux build.

Whether your specific test is proctored still depends on how that assessment was configured, not on one uniform company policy. Proctoring was inconsistent before this rollout too, with some candidates seeing no camera at all as recently as late 2025.

Before my test, I read every IBM HackerRank thread from the past two years on Reddit, Teamblind, and Quora. My prep workflow was built around interviewfox.ai for both the practice days and the test itself.

How to check. The homepage of the test link is the tell. If Proctor Mode is active, a webcam and screen-permission prompt appears before the timer starts.

I didn't see one on my test. That's consistent with proctoring varying by configuration, not a guarantee either way for anyone else's link.

That uncertainty is exactly why I ruled out desktop overlay tools before I ever sat down for the test. The failure-patterns section below explains this decision in more detail.

4 Other Confirmed IBM HackerRank Questions, 2023-2026

Beyond the 2 questions on my own test, several more IBM HackerRank questions are corroborated from 2023 through mid-2026, each reported by a different candidate.

Question 3: Unique Duplicate Values

Other candidates confirm this as a separate question in the same rotation, not the pairing I got. One January 2025 report on r/leetcode describes it as "extremely easy": given an array, return the values that appear more than once.

A hash set covering the array in one pass handles it in O(n) time.

def find_duplicates(nums: list[int]) -> list[int]:
    seen = set()
    duplicates = set()
    for n in nums:
        if n in seen:
            duplicates.add(n)
        seen.add(n)
    return list(duplicates)

Question 4: Array Rotation

A September 2024 r/leetcode report describes a question asking for an array or matrix rotated 90, 180, or 270 degrees, selected by a parameter. The confirmed approach is a layer-by-layer transpose-and-reverse for 90 degrees, applied once, twice, or three times depending on the requested angle.

def rotate_90(matrix: list[list[int]]) -> list[list[int]]:
    n = len(matrix)
    rotated = [[0] * n for _ in range(n)]
    for r in range(n):
        for c in range(n):
            rotated[c][n - 1 - r] = matrix[r][c]
    return rotated

Question 5: Matrix And Hashmap Pair

An August 2025 r/csMajors post describes this pairing as "really easy": a matrix traversal question paired with a hashmap counting question. No further detail on the exact matrix operation was given in that report.

That's a real gap rather than one I'm papering over — there's no code sample here because no source specifies the exact matrix operation.

Question 6: Increasing Triplets

The most recent confirmed question, from a June 2026 r/csMajors post, is functionally equivalent to LeetCode 334: determine whether an increasing subsequence of length three exists in an array. Its confirmed solution tracks the two smallest values seen so far in a single pass.

def increasing_triplet(nums: list[int]) -> bool:
    first = second = float('inf')
    for n in nums:
        if n <= first:
            first = n
        elif n <= second:
            second = n
        else:
            return True
    return False

Why India-Campus Question Banks Don't Count as US Evidence

TheJobOverflow and GeeksforGeeks carry a much longer list of IBM HackerRank questions. Every one of those threads is explicitly labeled as an India campus-hiring account, not the US Standard General Software track this article covers.

I used those threads only to confirm the pattern in a later section. None of the questions listed above draws on them as a source.

What IBM's HackerRank Test Format Actually Looks Like

Every report from 2024 through 2026 agrees on what IBM's online assessment contains: two coding questions, no multiple-choice section.

The clearest verified clock attached to those two questions is 60 minutes. That matches both my own test and a role-level Glassdoor listing that describes the assessment at roughly an hour.

Two Coding Questions, No MCQ, Confirming the Format

Both r/IBM and r/csMajors threads across 2024 and 2025 describe the same format: two coding questions, no MCQ, for the Standard General Software track. I got the same structure on my own test.

Reconciling the 60-Minute Timer

A Glassdoor listing for the role lists the assessment at roughly an hour. That lines up with my own test, which ran on a 60-minute timer.

I found unverified claims of other windows, but not stable source URLs strong enough to use as evidence in this version.

The 7-Day Link (and the One Report That Says 3-5 Days)

Four sources describe the test link expiring 7 days after it's sent. One of them is a verbatim quote from an actual IBM notification email.

One June 2026 report describes a 3-to-5-day window instead. That conflict is unresolved in the current evidence, so both numbers are stated here plainly.

How the Test Link Actually Arrives

The link comes by recruiter email. Later 2025-2026 reports show it landing on a hackerrank.com/test-v2 URL, while older 2023-2024 reports describe a hackerrank.com/test/ path instead.

Neither format changes what's inside the test itself.

What HackerRank's Proctor Mode Actually Monitors

HackerRank's own documentation lays out what Proctor Mode does on tests created after its July 2025 release. It captures webcam images every 5 seconds and screenshots every 15 seconds, tightening to every 5 seconds around a detected violation.

It also runs object detection in the webcam feed, specifically trained to flag phones and tablets. Tab-switching is flagged immediately, and copy-paste from outside the browser is disabled.

The code editor also runs a pattern check for suspicious type-delete-retype behavior. The system only supports Windows 10/11 and macOS Monterey or later, requires a single monitor in full-screen mode, and does not run on Linux at all.

How IBM's HackerRank Scoring Works

HackerRank scores each question as a percentage of test cases passed, not a single pass-or-fail flag. IBM has never published a minimum score to advance.

That partial-credit model is exactly why a perfect score and a rejection can coexist. It's also why a 5-out-of-15 result on one question doesn't tell you much on its own.

How scoring works. The score for each question is the percentage of test cases passed. Hidden test cases run and count toward that score, even though you never see them during the test.

The recruiter-facing report shows this raw percentage per question, never a rounded pass/fail label.

The visible-versus-hidden split shows up directly in two separate score reports. One candidate passed 12 of 15 hidden test cases on the first question, then failed 3 of 5 visible unit tests on the second.

Another passed 12 of 15 on the first question and a full 15 of 15 on the second.

A partial score's outcome is unconfirmed. One question fully passed, the second at 5 of 15 test cases: does that get a candidate selected? The math works out to roughly two-thirds, but nothing confirms a real cutoff.

No source in this research documents a US IBM candidate advancing on a partial score alone, and I'm not going to invent an answer that doesn't exist.

At least one candidate passed all test cases on a question "with an unoptimal solution." HackerRank grades on whether your code produces the correct output within the test's time limit.

Algorithm speed beyond that threshold doesn't factor in, so a working brute-force answer scores the same as an elegant one.

No guarantee either way. Three separate US candidates scored perfectly on both questions and were rejected anyway. No US-confirmed report in this research shows a partial score alone leading to an advance.

Put together, a full score is not a guarantee, and IBM's silence on a minimum score is itself the honest answer: there isn't a public one to give.

IBM HackerRank Exam-Day Strategy

Pacing between the two questions is where most confirmed accounts diverge. Community reports consistently describe Question 1 going quickly, with Question 2 as the one that eats the clock.

One r/csMajors report from January 2025 describes passing both questions in just 30 minutes — half the 60-minute window. On my own test, the split was closer: about 12 minutes on Question 1, close to 20 on Question 2.

Score-split reports back up the same pattern from a different angle. Whenever a candidate's report breaks down scores by question, the partial result is consistently on Question 2, not Question 1.

That matches my own experience. Question 1 resolved with a single clean pass at the logic, while Question 2 needed a false start before the approach held.

If your own pacing runs long on the second question, that's the expected shape of this test. It's not a sign you're behind some hidden benchmark.

Why Candidates Fail the IBM HackerRank Assessment

A full score on both questions has not guaranteed advancement for at least three separate US candidates. IBM's own plagiarism and originality checks can override a technically complete solution.

Both of these facts run against the assumption that clearing the coding bar is the same as clearing the assessment.

One candidate on an IBM Consulting Associate Developer new-grad track passed two easy-to-medium questions completely and was rejected anyway. Another candidate, on a different role, passed all test cases including hidden ones and was rejected "after a few days."

That's the only report in this research with a response-timing detail.

A third candidate independently hit the identical pattern. Three separate full-score rejections is enough evidence to state plainly that the OA works as a filter, not a guarantee of anything past that point.

In an India offline hiring drive, candidates who solved all three assessment questions still got rejected. The stated reason was that "uniqueness and logic of solution has more weightage than number of problems solved."

I did not find an equivalent US-specific plagiarism report in this research. I'm stating that gap directly, not assuming the India mechanism transfers one-to-one to the US track.

One rejection email was followed two days later by an actual interview invite, with no explanation for the reversal. I treat this as a sign that an automated rejection isn't always final, though I wouldn't count on it happening within any predictable timeline.

Using an overlay tool is its own failure mode. Desktop overlay or "invisible" AI tools render their answer on the same screen IBM's proctoring software is watching. The hiding mechanism is a basic OS-layer trick — the window stays out of visible view but still on-screen.

IBM's object detection flags a second screen in a screenshot. It also flags a phone held up in the webcam frame, and keeps adding capabilities as more candidates try AI during these tests.

interviewfox.ai works differently: the answer goes to my phone, a physically separate device. No screenshot, screen recording, or session monitoring can reach it, by design.

How to Prepare for the IBM HackerRank in 5 Days

Arrays, strings, and greedy or math reasoning account for nearly all of the confirmed IBM questions in this research. Dynamic programming, graphs, trees, and linked lists have not shown up in a single confirmed US report.

That distribution is what I built my own prep plan around. My invite landed with its 7-day clock already running.

Array and Greedy Topics Dominate the Confirmed Questions

Of the US-confirmed questions tabulated for topic frequency, most involve array manipulation, rotation, or deduplication. Others involve interval tracking, sorting with weighted sums, or greedy reasoning.

The June 2026 Increasing Triplets question fits the same array/greedy distribution and doesn't change the ranking.

My 3-Day Drill Plan With the Clock Running

With three days, I split my time by topic weight. Array manipulation took day one (LeetCode 26, 88, 442), and string pair and count problems took day two (LeetCode 242, 49).

Rotation and basic search took day three (LeetCode 48, 278, 217). I ran each problem cold first, then reviewed the pattern rather than memorizing the exact code.

In the days before my test, I also texted InterviewFox's Prep Agent over WhatsApp. I gave it the confirmed two-question format and the array-heavy topic weighting above.

It sent back a personalized three-day drill plan that matched what I'd already mapped out.

If your window is shorter. If your link gives you the more common 7 days, three focused prep days plus a buffer is realistic. If you land in the 3-to-5-day group instead, the same three-day plan compresses to two days of drilling and one day of rest.

I'd rather lose a rest day than walk in without having touched binary search at all.

What NOT to Study for This Role

No confirmed US report for this track covers dynamic programming, graph traversal, or tree problems. None cover linked lists, heaps, tries, or segment trees either.

I skipped all of them in my own prep and didn't need any of them on my actual test.

What Happens After You Submit the OA

Waits of two to eight weeks between the OA and the next stage are common in the data I found. None of them are a reliable rejection signal on their own.

IBM's SWE hiring process moves from a recruiter screen to a hiring-manager round after the online assessment clears. The actual gap between stages varies more than any official timeline suggests.

The Interview Sequence After the OA Clears

Two 45-minute interview rounds, split roughly 50/50 between technical and behavioral content, follow the OA. This is the stage where IBM's SWE hiring process actually slows down.

That structure matched what I was told to expect after my own OA cleared.

How Long the Silence Actually Lasts

One intern-track first response came about two weeks after the OA. Two separate interview rounds were followed by three weeks of silence with no update.

One Lowell, Massachusetts candidate was still listed as "In Interview Process" eight weeks after the interview — the longest confirmed gap in this research.

A reject email isn't always final. The same reject-then-invite reversal covered in the failure-patterns section applies here directly. A rejection email is not always the end of the process.

I wouldn't delete a calendar hold based on a rejection email alone until at least a few days have passed.

What the Technical Interview Actually Covers

IBM's coding interview stage for a US Software Developer role has covered Java and object-oriented programming fundamentals. It also included a walkthrough of a resume project, with no live LeetCode-style coding in that particular round.

I didn't reach this stage myself in time to confirm it against my own experience — I'm reporting it as a separate account, not something I lived through.

IBM Wraps Standard Algorithms in Enterprise-IT Scenarios

IBM consistently wraps standard algorithms — greedy logic, prefix sums, binary search, hashmaps — inside enterprise IT scenarios. It rarely presents them as pure algorithm puzzles.

I cross-referenced 15-plus question titles for this pattern, spanning both US and India-context reports. The underlying data structure work is always ordinary; the dressing is always operations, infrastructure, or cost.

The Enterprise-IT Pattern Across 15+ IBM Questions

Server monitoring, process scheduling, and supplier cost optimization show up as the scenario wrapper again and again. But the algorithm underneath — a sliding window, a greedy pass, an interval merge — is one any LeetCode grinder would recognize immediately.

Once I noticed this pattern, reading a new IBM-style problem stopped feeling unfamiliar, even when the exact scenario was new to me.

Server Monitoring and Load Management Questions

Confirmed India-context titles in this bucket include High-Load Timestamp Detection and Find Maximum Bandwidths. Both reduce to array or interval scanning problems once the server-monitoring language is stripped away.

One of these threads confirms an integer-overflow trap specifically: a timestamp calculation that needs a wider integer type than the language's default int.

Process Scheduling and Cost Optimization Questions

Non-Overlapping Intervals and Minimum Supplier Acquisition Cost are confirmed India-context titles. Both map directly to interval-scheduling and greedy cost-minimization, the same underlying category as the interval-tracking logic in my own Largest Area question.

The underlying greedy logic stays the same across every version of this scenario, even though the wording changes each time.

IBM's OA Is Easier Than Amazon's, Based on the Evidence

The clearest comparison point in this research is Amazon. IBM pairs two easy-to-medium questions in a 60-minute window, while Amazon pairs two medium-to-hard questions in 70 minutes.

I did not find a comparably sourced Google or Microsoft comparison, and I'm not going to construct one without evidence.

Based on the one data point that exists, the difficulty gap is real, not just the extra 10 minutes on Amazon's clock. IBM's OA sits below Amazon's difficulty level based on the one comparison this research has, not "FAANG-tier" broadly.

Google and Microsoft have no comparable OA data point in this research at all.

A secondhand Blind poll reference describes IBM's full coding interview loop (not the OA specifically) as harder than its reputation suggests. I'm flagging that second claim as thin — it's not tied to a specific post, and it covers the interview loop rather than the coding test this article is about.

FAQ

Is the IBM HackerRank test proctored?

It depends on the specific test link, not on a single company-wide rule. Some candidates get a webcam and screen-permission prompt before the timer starts. Others get none at all, based on how that particular assessment was configured.

Does the IBM HackerRank test have a camera?

For some candidates, yes. HackerRank's Proctor Mode captures webcam images every 5 seconds and screenshots every 15 seconds on tests configured for it. For others, including several 2024-2025 reports and my own test, no webcam and screen-permission prompt appeared at all.

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

Desktop overlay tools carry real risk. They hide the AI's answer on your screen using a basic OS-layer trick. That risk isn't fixed, since HackerRank's detection keeps evolving as more candidates try AI-assisted approaches.

The alternative is interviewfox.ai. It pushes the answer to your phone instead — a separate device no screenshot or recording can reach, by design.

The laptop screen stays on the exam editor the whole time. That dual-device architecture removes the answer from your screen entirely.

What are the real IBM HackerRank test questions and answers?

Six are confirmed from 2023 through mid-2026. The first four are Largest Area, Sorted Sums, Unique Duplicate Values, and Array Rotation.

The remaining two are a Matrix-and-Hashmap pairing and Increasing Triplets. The questions with enough detail are explained with working solutions above.

What does Reddit say about the IBM HackerRank test?

Reddit threads across r/IBM and r/csMajors from 2024 through 2026 describe a consistent two-question, no-MCQ format. Most also report a 7-day link expiry. Multiple separate accounts also describe a perfect score not guaranteeing advancement.

Is the IBM backend developer HackerRank test different from the Standard General Software track?

I found claims that the Backend track can differ from the Standard General Software track, but I could not verify a stable source URL for the SQL-specific claim. For this version, treat the Standard General Software format above as the verified scope.

Is IBM's coding assessment hard compared to other companies?

Based on the available data, somewhat. IBM's two easy-to-medium questions are less demanding than Amazon's, which pairs two medium-to-hard questions on a longer clock.

No sourced comparison to Google or Microsoft's OA difficulty exists in this research.