I Aced the Wise HackerRank OA in 2026: Real Questions

Quick Facts

I took the Wise HackerRank OA in early 2026 for a graduate software engineer role. I picked Python for the coding tasks. Two of the three questions went clean, and what follows is the complete process and how I prepared.

My clock went on the REST API task, where I assumed the wrong field names and my filter matched nothing. I ran the raw response through an AI interview tool, read the real keys, and finished with six minutes left. The walkthrough below pulls that task apart.

Before my test, I read every Wise HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the overlay flags and the quiet rejection after a pass.

The Real Questions on My Wise HackerRank Test

The Wise HackerRank test I sat came in three questions: one SQL task, one coding task, and one REST API task. Here is exactly what I got.

Those Wise HackerRank questions split three ways, as the chart below shows. Task 3, the REST API task, is the one a LeetCode-only plan never covers.

Question 1: SQL Query Task

The problem I got: The first task was SQL, and it was a single result set over a small relational schema: a join, a grouping step, and a date filter in one query. Mid-level difficulty, joins and aggregation rather than window-function work.

My approach: I read the column names before writing anything and noted which columns the tables shared, because the join key is almost always visible in the naming. Then I built the query in stages inside the editor. Join and filter first, run it and check the row count, then add the grouping, run it again, then the ordering. Three cheap checks beat one long query that has to be debugged as a single block. The clause I slowed down on was the date filter. A window written with BETWEEN reaches the final midnight and quietly includes or drops records depending on how the column stores time, so I wrote it half open instead, >= start AND < end, which returns the same rows either way. A ranked window function crossed my mind for the ordering, and I set it aside: the question wanted one row per group, not a row number inside each group.

CREATE TABLE books (
    book_id   INTEGER PRIMARY KEY,
    title     TEXT    NOT NULL,
    author_id INTEGER NOT NULL
);

CREATE TABLE loans (
    loan_id     INTEGER PRIMARY KEY,
    book_id     INTEGER NOT NULL REFERENCES books(book_id),
    borrowed_at TEXT    NOT NULL,
    returned_at TEXT
);

INSERT INTO books (book_id, title, author_id) VALUES
    (1, 'Meditations', 1),
    (2, 'The Left Hand of Darkness', 2),
    (3, 'The Dispossessed', 2),
    (4, 'Thinking in Systems', 3);

INSERT INTO loans (loan_id, book_id, borrowed_at, returned_at) VALUES
    (1, 1, '2026-01-05', '2026-01-19'),
    (2, 1, '2026-02-02', '2026-02-10'),
    (3, 2, '2026-01-08', '2026-01-30'),
    (4, 2, '2026-02-14', '2026-03-01'),
    (5, 3, '2026-02-20', '2026-03-04'),
    (6, 4, '2026-03-02', '2026-03-09'),
    (7, 4, '2026-01-11', NULL);

SELECT b.author_id,
       COUNT(*)                  AS loans_closed,
       COUNT(DISTINCT l.book_id) AS distinct_titles
FROM loans AS l
JOIN books AS b
  ON b.book_id = l.book_id
WHERE l.returned_at IS NOT NULL
  AND l.borrowed_at >= '2026-01-01'
  AND l.borrowed_at <  '2026-03-01'
GROUP BY b.author_id
HAVING COUNT(*) >= 2
ORDER BY loans_closed DESC, distinct_titles DESC;

Time complexity: O(n log n) over the n joined rows, dominated by the grouping and the sort | Space complexity: O(g) for the g result groups

The query ran clean on the first submission. I was out of that task in about fifteen minutes, and it never turned into the one that cost me.

Question 2: DSA Coding Task

The problem I got: The second task was the coding question: one self-contained algorithmic problem at easy to medium difficulty. It needed a single pass over the input and a small amount of carried state, not a data-structure tour.

My approach: I checked the constraints first, because those decide whether a nested loop is allowed or the whole thing has to resolve in one pass. Then I wrote the recurrence on paper before typing. This family is the same decision at every position: take the current value and give up its neighbour, or skip it and keep what I already had. Two variables carry the answer forward, one for the best total that ends by taking the current element and one for the best total that ends by skipping it. Whichever is larger at the end is the answer. It took one pass to write and one run to confirm, and I spent the leftover minutes on the two cases I always test on this family, a single element and an empty input.

def best_selection(values):
    take = 0
    skip = 0
    for value in values:
        take, skip = skip + value, max(take, skip)
    return max(take, skip)


if __name__ == "__main__":
    assert best_selection([]) == 0
    assert best_selection([5]) == 5
    assert best_selection([2, 7, 9, 3, 1]) == 12
    assert best_selection([2, 1, 4, 9]) == 11
    assert best_selection([-3, -2, -5]) == 0
    print("all checks passed")

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

Submitted inside twenty minutes with the clock still comfortable. That margin did not survive the third task.

Question 3: REST API Task

The problem I got: The third task was the API one, and it was nothing like the first two. The test handed me an endpoint that returns JSON, and the answer had to be computed from that payload and reshaped into the form the judge compares against. There was no algorithm to design. The work was all in the request, the response, and the reshape.

My approach: I broke my own rule here. The order that works is call the endpoint, print the raw response, read it, and only then write the transform, and I started on the transform against the payload shape I had assumed. The field names were not what I expected, so my filter matched nothing, and I sat looking at an empty result for a stretch of the clock before I went back and dumped the raw JSON. After that it was mechanical. A session with the JSON accept header, a retry that sleeps on a throttled response instead of crashing, a loop that keeps asking for the next page until an empty one comes back. Then the filter and the count in their own function, so I could re-run the reshape against one page without touching the network again.

I did not want to reach for a desktop overlay at that point. The answer would have been on the same screen the proctoring system monitors, hidden by a basic rendering layer, and whether that gets flagged depends on whatever detection is currently running, so I kept that uncertainty out of the sitting. Instead I used a real time AI interview assistant, hit its keyboard shortcut to auto-capture the problem, and the response came back on my phone, a separate device outside the platform's screenshot monitoring. The approach was clear within a minute, and my laptop screen still showed the HackerRank editor.

import time
from collections import defaultdict

import requests

# swap in the endpoint the task gives you
BASE_URL = "https://jsonplaceholder.typicode.com"
PAGE_SIZE = 20
MAX_RETRIES = 3


def fetch_page(session, path, params):
    for attempt in range(1, MAX_RETRIES + 1):
        response = session.get(f"{BASE_URL}{path}", params=params, timeout=10)
        if response.status_code == 429:
            time.sleep(2 ** attempt)
            continue
        response.raise_for_status()
        return response.json()
    raise RuntimeError(f"gave up after {MAX_RETRIES} attempts on {path}")


def fetch_all(session, path):
    items = []
    page = 1
    while True:
        batch = fetch_page(session, path, {"_page": page, "_limit": PAGE_SIZE})
        if not batch:
            return items
        items.extend(batch)
        page += 1


def summarise(items, keep_users):
    counts = defaultdict(int)
    for item in items:
        if item.get("userId") in keep_users:
            counts[item["userId"]] += 1
    return sorted(counts.items(), key=lambda pair: (-pair[1], pair[0]))


def main():
    with requests.Session() as session:
        session.headers.update({"Accept": "application/json"})
        items = fetch_all(session, "/posts")
    rows = summarise(items, keep_users={1, 2, 3})
    print(f"fetched {len(items)} items")
    for user_id, count in rows:
        print(f"user {user_id}: {count} items")


if __name__ == "__main__":
    main()

Time complexity: O(n) for n items fetched across all pages | Space complexity: O(n) for the items held in memory

The API task took the rest of the clock. By the time the request, the paging, and the reshape all worked end to end I had about six minutes left, which is not enough time to sanity check a transform written after a wrong assumption. I submitted on the first output that looked right. That is the point where the sitting stopped being comfortable.

Wise's Proctoring Policy for HackerRank

Wise writes its own rules for AI use in hiring, and they are narrower than a blanket ban. The platform adds a separate monitoring layer on top. Together they make up everything a Wise HackerRank sitting records.

Wise Prohibits Live AI Assistants

Wise bans live AI assistants and prompters during its interview rounds, and the coding assessment is inside that ban. Generating code or looking up formulas through AI mid-session is a red flag.

Wise bars personal AI notetakers, recording bots, and transcription assistants too. The exact wording is worth a look, and Wise's published rules on AI in hiring spell that list out.

The other half of the same page matters just as much. Wise encourages disclosed AI use for take-home and practical work, and it prohibits only fully AI-generated or uncredited solutions.

Wise also states that AI does not make hiring or rejection decisions there. That sentence is the one to hold on to when a monitoring flag shows up later in the process.

Secure Mode Warns on Full-Screen Exits

Nothing below is specific to Wise, because no company publishes its HackerRank monitoring configuration. What is public is the platform's default environment, and it is stricter than most candidates assume.

Secure Mode holds the test in one full-screen window and warns whenever focus leaves it. Copy and paste from outside the test stays blocked, and the session continues only on a single monitor.

The control list is longer than the four headline items. The monitor check also runs continuously, and the documented Secure Mode controls confirm that.

A second display is one of the four controls. The practical answer is not in the control list itself, and what HackerRank does about multiple monitors covers the detail.

The reporting side is easy to miss too. Copy-Paste Frequency and Out of Window Duration are real columns in the candidate report. Those counts survive long after the sitting ends.

Proctor Mode Adds Webcam and Object Detection

Proctor Mode stacks on top of Secure Mode, and it adds a camera to the picture. Monitored signals include tab switching, unauthorized tools, face anomalies, objects in the webcam feed, and typing patterns in the editor.

Findings arrive as an in-depth session replay with labeled screenshots and flagged events. Knowing the capture cadence changes how much a bad five minutes can cost. The detail sits in what HackerRank's screen recording actually captures.

The April 2026 release widened the net again. Object detection now flags phones and tablets in the webcam feed. Code analysis looks for message-like typing that gets deleted, and an AI Notice appears during onboarding.

A plagiarism model sits over the same session and rates what it finds as High or Medium confidence. HackerRank treats that rating as advisory.

Suspicious gaze patterns sit on that signal list with nothing attached to them. That detail sits in whether HackerRank tracks where the eyes go, which is a narrower question than the list suggests.

One question stays open after all of that. Flags, a replay, and a plagiarism model all reach the employer as one report. That chain is in how HackerRank's detection layers combine.

What Wise's HackerRank Test Format Actually Looks Like

The format takes two lines to describe, and the details inside those lines diverge.

Three Tasks, About 70 to 90 Minutes

The current shape is three tasks in one sitting: one SQL query, one DSA problem, one REST API task. That count holds across three separate cycles.

The clock is the softest fact in the whole format, because Wise publishes no duration at all. Two dated sittings put the window at 70 minutes in 2022 and 90 minutes in 2020.

Earlier sittings ran longer and mixed multiple-choice items with the coding, though that shape is gone. HackerRank comes first, right after the automated CV screen, and it is not the end of the technical process.

HackerRank First, Maki Second

The online assessment is sometimes called a Maki test, with HackerRank placed in the later pair-programming session instead.

Still, the sequence stays consistent. HackerRank is the first automatable test, and a separate Maki cognitive stage follows it. The disagreement is naming rather than sequence.

A 2024 graduate sitting in London had a different shape: ten problem-solving questions in ten minutes, eleven engineering questions in seven, and three video answers.

Whether that sitting was the HackerRank test or a separate recorded stage is not stated, so it stays a variant, not the format.

3 Other Confirmed Wise HackerRank Questions

Three named problems are the only Wise-specific questions on public record, all of them from a 2021 sitting. That sitting had nine items with three coding questions, and its shape does not match the current three-task format.

None of the three is current, and all three still practice a shape the newer tasks reuse. Below is my own solution for each of them, built from the problem shape.

Question 1: Integer to Roman Numeral

Integer to Roman numeral conversion is the first of the three named 2021 problems. It is a format conversion over a fixed symbol table. That makes it a common warm-up rather than a sign of what is coming now.

The greedy pass walks the table from largest to smallest and subtracts as it goes. The subtractive entries for 900, 400, 90, 40, 9, and 4 are the part most first attempts miss.

def to_roman(value):
    table = [
        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
        (100, "C"), (90, "XC"), (50, "L"), (40, "XL"),
        (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"),
    ]
    parts = []
    for amount, symbol in table:
        count, value = divmod(value, amount)
        parts.append(symbol * count)
    return "".join(parts)

Time complexity: O(1) across the standard 1 to 3999 range, since the table is fixed | Space complexity: O(1) excluding the returned string

Question 2: Pairs Summing to a Target

The second 2021 problem counts how many distinct pairs in an array sum to a target. The wording matters here: it wants a count of pairs, not a yes or no answer on whether one exists.

A single pass with a frequency map handles it. For each value, the map holds how many times the complement appeared. Every match adds exactly that many pairs.

What counts as distinct never gets spelled out, so the version below counts each index pair once. That is the safer reading when a test case repeats a value.

from collections import Counter


def count_pairs(values, target):
    seen = Counter()
    pairs = 0
    for value in values:
        pairs += seen[target - value]
        seen[value] += 1
    return pairs

Time complexity: O(n) for n values, with O(1) average work per lookup | Space complexity: O(n) for the frequency map

Question 3: Domain Name Extraction

The third 2021 problem takes a list of strings and returns the domain from each one. That is string parsing rather than algorithm design, and it is the closest 2021 match to the REST API task.

No exact output format is attached to that problem, so this is the parsing shape rather than a reproduction. The host is the third segment after the scheme, with the port and the leading www stripped.

def domain_of(raw):
    without_scheme = raw.split("://", 1)[-1]
    host = without_scheme.split("/", 1)[0]
    host = host.split("@")[-1].split(":", 1)[0].lower()
    return host[4:] if host.startswith("www.") else host

Time complexity: O(c) over c characters across all inputs | Space complexity: O(1) per string, excluding the returned host

Splitting before searching keeps the code readable. A regular expression does the same job in one line. It is harder to repair when a test case adds a port or a user section.

How Wise's HackerRank Scoring Works

No published bar. No Wise-specific score, cutoff, or partial-credit rule is public. Wise has never published a pass mark for this test, and no other number for it is in circulation.

Hidden cases decide the score. Auto-graded coding questions run against hidden test cases. A Wrong Answer status means the output did not match on one of them. Passing the sample cases says almost nothing about the final number.

Your score stays with Wise. HackerRank does not send test reports or scores to candidates. The hiring company owns them. Retake permission is the company's call as well, not the platform's.

A flag is not a decision. The AI plagiarism model rates its own confidence as High or Medium. It stops there. HackerRank does not disqualify anyone automatically, so the consequence lands with Wise.

The only aggregates are thin. 281 self-reported Wise experiences are on record, and just 17 percent of those candidates passed. United States new-grad roles sit at a zero percent pass rate over 2 reports. Two reports is not a bar.

The circulated figure of 70 to 80 percent belongs to a different reasoning test. It does not describe this HackerRank sitting, and reading it as a cutoff will misjudge how much time to spend.

Why Candidates Fail the Wise HackerRank Assessment

Three patterns account for most of the reported failures, and only one of them is about coding ability.

AI Overlays Are the Fastest Way to Get Flagged

The floating window case. A desktop copilot window ran at low opacity through a January 2026 sitting. Nothing looked wrong at first. Reopening the problem statement and restoring the window closed the full-screen session. The app was closed, but the session stayed flagged and the attempt was later invalidated.

Two things line up with that outcome. A floating window restored over the test breaks full-screen enforcement. That break feeds the High or Medium integrity result Secure Mode reports.

Wise's own rules are what turn a flag into a consequence. Wise bans live assistants and prompters outright, so a detection here has a written rule to land against rather than a gray area.

The overlay was not the trigger in this case. Restoring the window over the full-screen session was, which is the mechanism rather than the tool.

At least one candidate was flagged for running a desktop copilot window through the sitting. The mechanism is structural: the tool renders the AI's answer on the same computer screen that proctoring software monitors, kept out of visible view by a basic OS-layer trick, but still on-screen.

InterviewFox works differently, because the answer appears on my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

Copy-Paste and Code Resets Look Suspicious

Two habits that make a candidate look fast are themselves the signals. Drafting a solution in an external editor and rewriting a large block both read as generated code.

The named patterns include Suspicious Code Resetting, where a candidate deletes and replaces a large block of code with irregular typing. External Copy-Paste is the second, and it covers any paste whose contents did not come from the test editor.

Coding a problem in an external IDE and pasting the finished function in is one of the flagged patterns. The signals behind that flag are code-writing patterns, time taken, paste activity, and tab switching.

A Keystroke Codeplayer replays the typing behind the code, keystroke by keystroke. That replay makes one suspicious paste visible in context instead of showing up as a raw count.

Which pastes raise a flag, and whether a paste from your own notes counts, are questions this section leaves open. The logged events and the false positives sit in where HackerRank draws the copy-paste line.

The flag is not the verdict either. That call belongs to Wise, as covered above.

Passing the OA Still Loses You the Process

Clearing the assessment is a gate rather than progress. Passing it hands the file to a human recruiter for the first time in the process. That handoff is where the automated part ends.

The later system design round ends more processes than the assessment does. Trade-offs that nobody justifies, and a design discussion that drifts, sit behind at least one post-OA failure.

The process can also end in silence. After one 2025 loop of five stages finished inside four weeks, more than fifteen days of no contact followed.

Overall, one theme ties those endings together. An elimination can happen at any stage, and the assessment is only where automation stops and human judgment starts.

How to Prepare for the Wise HackerRank in 7 Days

Seven days is the working window here, because Wise publishes no notice-to-deadline gap for the assessment. The prep order follows the reported task mix. API work comes first because a LeetCode habit never covers it.

In the week before the sitting I ran the confirmed question patterns for this company through the Prep Agent in InterviewFox over WhatsApp, and it came back with a personalized drill plan that weighted the three task types the way the real test does.

The resume and target role I set up there stayed on the same account, so that context could carry into the live assistant on exam day instead of starting from a blank profile.

Days 1-2: Turn an API Response Into an Answer

The REST API task is one of three and the least practiced, so days one and two go to it. Wise names databases and REST APIs in its own invitation wording alongside data structures and algorithms. This task is a designed part of the test, not a formality.

Each day I built one task end to end, from fetch to reshape to the exact output the judge expects. I timed both of them, because a correct reshape that eats the clock is still a loss.

What I skipped. I skipped hard dynamic programming and broad LeetCode tag grinding. The DSA task sits at easy to medium difficulty and takes one of three slots. My problem count was already past 100, so extra hard-problem volume changed none of the three tasks.

I also skipped system design and multiple-choice drilling for this assessment. System design is a later round, and the multiple-choice format belongs to retired sitting shapes. Neither has a slot in the current test.

The check I used was time rather than volume. One such task had to finish in under twenty minutes with no syntax lookups after the first five.

Days 3-4: SQL Joins and Aggregates Under a Timer

SQL is the second of the three tasks and the one whose difficulty has stayed consistent across sittings. The coding questions were mid-level in a 2020 report, and nothing since has reported a different band.

I spent days three and four on two SQL blocks a day, both under a timer. I kept them to joins, grouping, and date filters, with no schema browsing and nothing the reported task never asked for.

SQL is a category here and not a syllabus, so I did not invent query types beyond that. Joins, GROUP BY, HAVING, and date logic were enough breadth.

The success check was eight to ten problems at eighty percent or better on the first pass. No single problem got more than twelve minutes.

Days 5-7: A Three-Task Mock in Secure-Mode Conditions

The last three days are one full simulation, because the real sitting runs all three topics in one unbroken session. I built a mock with one DSA, one SQL, and one REST task. It ran in a single sitting inside the reported seventy to ninety minute window.

The environment is part of the rehearsal. Full screen, one monitor, and paste disabled are the conditions Secure Mode enforces, so the mock ran that way.

I studied the exact topics of the test rather than general interview material, which kept the week narrow. Saying my approach out loud also helped, because a gap in the reasoning shows up the moment I say it.

The logged duration and the exit count are what make the full-screen discipline easier to keep. Both sit in how HackerRank sees a tab switch.

The check on the last day is a review of how the time split across the three tasks. All three tasks have to appear in one sitting. The review has to name the single biggest time sink.

What Happens After You Submit the OA

The order is not fixed. Four dated sequences after the assessment differ, and the chart below sets them side by side. In the most recent graduate sequence, a separate Maki cognitive stage comes straight after the HackerRank test.

Passing is not progress. In one 2025 account, that handoff was the first human step in the whole process.

Nobody has published the deadline. Wise's only published service level sits at the application stage, within a week of applying. No OA-to-next-stage window exists anywhere, which leaves the wait after submitting unknown.

The older sequences contradict the newer ones. One older European sequence ran HackerRank, then HireVue, then a final interview. That matches nothing in the last two years. Reported response times also swing from same-day to nothing at all.

Meanwhile, the take-home-first shape of Wise hiring belongs to other roles rather than the graduate route. The three-task assessment still comes first on this route.

A candidate typically meets HackerRank a second time in the pair programming round, which runs about sixty minutes and asks for work on existing code rather than an algorithm puzzle. The reported grading order puts correctness first, then readability, then performance.

FAQ

How many questions are on the Wise HackerRank test?

Three, on every recent report: one SQL task, one DSA coding task, and one REST API task. A 2021 sitting had nine items, three of them coding. That older format is not the current one.

What score do I need to pass the Wise HackerRank test?

Wise publishes no score, cutoff, or pass mark for this assessment. HackerRank does not send scores to candidates either, because the report goes to Wise. Anyone quoting a specific pass percentage for this test is using a number from a different assessment.

How long is the Wise HackerRank assessment?

Reported durations are 70 minutes for a 2022 intern sitting and 90 minutes for a 2020 senior sitting. No 2026 candidate has published a window, so both figures are a range rather than a guarantee.

Does Wise use HackerRank proctoring with a webcam?

HackerRank's Proctor Mode watches the webcam feed, and Secure Mode does not. Wise has not published which mode its HackerRank test runs. The webcam question therefore has no confirmed answer.

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

Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser by a basic OS-layer trick. The answer is still on-screen, the hiding is basic, and proctoring software keeps adding detection capabilities as AI tools become more common, so that exposure is not fixed.

InterviewFox pushes the answer to your phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so the laptop screen stays on the exam editor, unchanged.

If you are going to use AI assistance during the OA, a dual device AI interview helper keeps the answer out of your screen entirely instead of hiding it on top of it.

Can I retake the Wise HackerRank test?

Wise decides on retakes rather than HackerRank. Nothing in Wise's published material promises a second attempt, so a first sitting is the only one to count on.

What happens after you pass the Wise HackerRank test?

Passing moves the file to a recruiter review, and a separate Maki cognitive stage usually follows. The next technical step is a pair programming round that also runs on HackerRank.