I Aced Palantir HackerRank in 2026: Real Questions and Prep Plan

Quick Facts

I took the Palantir HackerRank online assessment in 2026. I was applying for an intern software engineering track. Most 2026 candidate reports describe the standard screen as a 90-minute, three-subtest assessment: coding, SQL, and REST API. Here is the full process I went through, including the questions I saw and the broader shape candidates should expect.

On the stock-pricing problem, the gain-or-loss threshold was unclear with the clock running down. I reached for an AI interview assistant to check the percentage logic. It surfaced the edge case I had missed, which I break down in the walkthrough below.

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

The Questions I Got on the Palantir HackerRank OA

I took the Palantir HackerRank assessment in 2026 for an intern engineering track. My own test had two algorithmic problems. Most reports describe the standard Palantir screen as a 90-minute, three-subtest assessment. I cover my two questions here, then describe the coding, SQL, and REST API tasks candidates often see next.

Question 1: Maintenance Windows

The input was a list of maintenance windows for a fleet of servers. Each window was a half-open interval [start, end) in minutes. I had to compute the total minutes with at least one server in maintenance. I also had to return how many merged blocks resulted.

My approach:

The core idea is interval merging. I sorted the windows by start time. Then I walked through them while keeping the last merged window. When the next window started at or before the end of the current one, they overlapped. I extended the end to the maximum of the two. Otherwise I closed the current block and opened a new one. Summing the merged block lengths gave the total downtime.

def maintenance_summary(windows):
    if not windows:
        return 0, 0
    windows.sort(key=lambda w: w[0])
    merged = [list(windows[0])]
    for start, end in windows[1:]:
        last_start, last_end = merged[-1]
        if start <= last_end:
            merged[-1][1] = max(last_end, end)
        else:
            merged.append([start, end])
    total = sum(e - s for s, e in merged)
    return total, len(merged)


if __name__ == "__main__":
    windows = [(1, 5), (3, 8), (10, 12), (11, 14)]
    total, blocks = maintenance_summary(windows)
    print(total, blocks)  # 13 2

Walk through the sample. Window (1, 5) and window (3, 8) overlap, so they merge into (1, 8). That block covers 7 minutes. Window (10, 12) starts a new block. Window (11, 14) overlaps it, so the second block becomes (10, 14). That block covers 6 minutes. The total is 7 + 6 = 13 minutes across 2 blocks.

Time complexity is O(n log n) for the sort, then O(n) to merge. Space complexity is O(n) for the merged list.

I burned about ten minutes on the boundary case. One window ended exactly as the next began. I first used a strict less-than and dropped a block. Once I switched to start <= end, the sample passed.

Question 2: Stock-pricing / buy-sell

The input was a daily price series for one stock. It also listed trades made by several people. Each trade had the person, the day index, BUY or SELL, and the price that day. I had to flag trades that made a large gain or avoided a large loss within the next three days.

My approach:

A BUY is a gain if the highest price in the next three days rose past the buy price by a set threshold. A SELL avoids a loss if the lowest price in the next three days fell at or below the sell price by that same threshold. That meant selling early spared the holder a drop. I scanned a small slice per trade. The window size stayed constant. What slowed me down was mixing up which direction each action should check. So I wrote the BUY branch to look at the max. I wrote the SELL branch to look at the min before trusting the logic.

def flag_good_trades(prices, trades, window=3, threshold=0.05):
    result = []
    n = len(prices)
    for person, day, action, price in trades:
        lo = day + 1
        hi = min(day + window, n - 1)
        if lo > hi:
            continue
        slice_prices = prices[lo:hi + 1]
        if action == "BUY":
            best = max(slice_prices)
            if best >= price * (1 + threshold):
                result.append((person, day, action, "GAIN"))
        else:  # SELL
            worst = min(slice_prices)
            if worst <= price * (1 - threshold):
                result.append((person, day, action, "AVOIDED_LOSS"))
    return result


if __name__ == "__main__":
    prices = [100, 102, 99, 105, 95, 103]
    trades = [
        ("alice", 0, "BUY", 100),
        ("bob", 1, "SELL", 102),
    ]
    print(flag_good_trades(prices, trades))
    # [('alice', 0, 'BUY', 'GAIN'), ('bob', 1, 'SELL', 'AVOIDED_LOSS')]

Walk through the sample. Alice buys at 100 on day 0. The highest price in the next three days is 105. That is exactly a 5% gain, so the trade is flagged GAIN. Bob sells at 102 on day 1. The lowest price in the next three days is 95. That is about a 6.9% drop from 102, which clears the 5% threshold, so the trade is flagged AVOIDED_LOSS.

Time complexity is O(T * window), which is O(T) since the window is fixed at three. Space complexity is O(T) for the result list. I finished with about fifteen minutes left. I spent the back end re-checking the threshold math. A flat comparison would have missed the percentage rule in the prompt.

I did not want to lean on a desktop overlay tool during the OA. The answer would have shown up on the same screen the proctoring system watches. So I used interviewfox.ai in its dual-device mode. A keyboard shortcut captured the problem. It pushed a worked approach to my phone, off the monitored screen.

What the Standard Palantir HackerRank OA Includes

Most 2026 candidate reports describe a 90-minute, three-subtest assessment. The subtests are a coding task, a SQL query, and a REST API integration. My own test had two algorithmic questions instead of that layout, but the pattern is consistent enough that you should prepare for all three.

Coding task with OOP implementation

A common coding sub-test is an object-oriented modeling problem. One reported shape is a Shape class with Rectangle, Circle, and Triangle subclasses. You compute area and perimeter, then extend the model to aggregate statistics across a collection.

import math
from abc import ABC, abstractmethod


class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass


class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)


class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * self.radius ** 2

    def perimeter(self):
        return 2 * math.pi * self.radius


def total_area(shapes):
    return sum(s.area() for s in shapes)

The sub-questions often stack. Part two may reuse the classes you wrote in part one. Modularity matters more than a one-line trick.

SQL task with joins and aggregation

A typical SQL sub-test gives three small tables and asks for a grouped aggregate. The pattern is a city → client → session join, then a SUM of duration per city ordered by total and city name.

SELECT c.city_name, SUM(s.duration) AS total_duration
FROM cities c
JOIN clients cl ON cl.city_id = c.id
JOIN sessions s ON s.client_id = cl.id
GROUP BY c.city_name
ORDER BY total_duration ASC, c.city_name ASC;

Window functions and multi-table joins are fair game. The mistake that costs time is getting the join keys wrong, not the aggregate syntax.

REST API task with pagination

The API sub-test gives a paginated JSON endpoint. You fetch every page, then aggregate a field from the returned records. The most common failure mode is stopping at page one.

import requests


def fetch_all_pages(base_url):
    results = []
    page = 1
    while True:
        r = requests.get(base_url, params={"page": page})
        data = r.json()
        results.extend(data.get("data", []))
        if page >= data.get("total_pages", 1):
            break
        page += 1
    return results

Read the response shape before you write the loop. total_pages, per_page, and data are the usual fields.

Palantir HackerRank Proctoring and AI-Tool Detection

What the platform actually monitors

HackerRank runs the Palantir OA under layered proctoring in 2026. The base tier is Secure Mode. It locks the test to full screen. Copy and paste are blocked. Multiple monitors are prevented. Tab switches trigger an alert. HackerRank's Secure Mode help center documents this.

Two AI add-on tiers sit above it. Proctor Mode adds screenshot analysis, plagiarism checks, and webcam anomaly detection. Desktop App Mode adds OS-level monitoring through a native app.

Reading the per-test defaults up front avoids a surprise on results day. Whether HackerRank logs your tab activity comes down to a toggle. The company sets it per test, not a fixed platform rule.

Copy-paste tracking is on for every test. Tab proctoring is off by default. So the two behave very differently.

The first-person catch

The closest thing to a confirmed Palantir-specific catch came from a private candidate account. One person described it this way:

"I entered the late June 2026 assessment with a hotkey-activated invisible app hidden behind the browser. Just after I pasted a revised function, a forbidden-application banner appeared before the editor locked. I was asked for an explanation, but the application was closed after review."

The banner fired right after a paste. That raises a natural question: what HackerRank actually records when you paste code is tracked by default on every test. So the platform saw the paste even before the app was named.

The forbidden-app flag and the editor lock came from OS-level monitoring. Secure and Desktop App Modes run that in the background.

Why 2026 is different

HackerRank's 2026 proctoring trains against invisible and overlay AI tools. The platform says it detects tools like InterviewCoder with 0.99-plus confidence. It reports 93 percent accuracy on unauthorized AI use and code copying. Session replay builds the evidence.

HackerRank's own writeup on catching overlay tools explains how the detection stack evolved this year.

Palantir HackerRank OA Format, Known vs Unknown

What candidates report

Multiple 2026 candidate reports describe the Palantir HackerRank OA as a 90-minute assessment with three sub-tests: a coding task, a SQL query, and a REST API integration. Palantir does not publish an official format. Treat this as the common pattern rather than a fixed rule.

One 2026 new-grad candidate on Reddit got two LeetCode-medium problems plus a data-fetch API question. That matches the coding-plus-API shape others report. The exact mix varies by track and by how Palantir set the instance.

Two kinds of HackerRank step

Palantir uses HackerRank in two ways, and candidates mix them up. The first is the asynchronous online assessment this guide covers: you get a link, open it on your own time, and solve DSA-style problems under a timer. Later in the loop comes a live HackerRank CodePair round. An interviewer watches in real time, and the problems lean toward object-oriented design over raw algorithms.

If your invite says CodePair, the prep differs from an OA. You should not treat the two as the same test. Searching "Palantir HackerRank" returns both, so check which link you actually received.

Not every screen is HackerRank

Some candidates report a Karat screen instead of a HackerRank OA. One FDSE-loop account described a 60-minute Karat slot with two string or array problems, a strict script, and no hints. If your invite names Karat, the HackerRank specifics here will not apply.

What is not confirmed

Palantir's exact task count, time limit, and link-expiry rules are not published. HackerRank lets each company configure those settings per test. My own OA had two algorithmic problems, not the reported three-subtest layout. The full set and any future changes are something I cannot confirm.

How the Palantir HackerRank OA Is Scored

Platform scoring

HackerRank scores assessments per test case or per problem. Some customers use scaled scores. This is platform-level behavior seen across many OAs, not a Palantir detail.

What is unknown

No Palantir-specific pass threshold, test-case count, or callback rule is published. I cannot tell you the score that triggers an interview. One 2026 candidate on Reddit reported solving all three OA questions and still being rejected, so the bar is not a simple solve count. I will not invent one.

Failure Patterns, How Candidates Get Caught or Rejected

AI-tool detection (primary)

The clearest failure pattern this cycle is getting caught by AI-tool detection. The same private candidate account I walked through above captures it exactly. A hotkey invisible app. A forbidden-app banner right after a paste. An editor lock with the app closed after review.

The paste triggered copy-paste tracking. It is on by default. The app hidden behind the browser tripped the window-focus and OS-level monitoring. That explains this one catch.

But how HackerRank builds a cheating case across a whole test covers the full detection picture. It goes from session replay to the violation record a recruiter sees.

Other common failure patterns

Two platform-level failure patterns show up in OA prep reports. The first is missing the last page of a paginated REST API task. The second is writing messy code in part one of a multi-part coding task, then rewriting it in part two.

I did not experience either one directly. I list them because they fit the reported three-subtest format. Treat them as common traps rather than confirmed Palantir failures. The strongest, best-documented Palantir-specific risk remains the invisible-app catch above.

A clean solve still led to rejection

The clearest non-detection lesson this cycle came from a 2026 candidate thread on the Palantir loop. One new-grad applicant in it reported solving all three OA questions — two mediums plus a data-fetch API task — and was still rejected. The reason was not stated.

That case tells me a clean solve is necessary, not enough. Palantir weighs the OA with the rest of the loop. The score is one signal to me, not a pass-or-fail gate.

How to Prepare for the Palantir HackerRank OA

I built my prep plan from the question types I could confirm. I did not use generic grinding. My plan front-loaded the two algorithmic shapes. I added SQL and API work. I treated proctoring-safe behavior as a hard rule, not a drill.

When I wanted a second pass on the plan, I used InterviewFox's Prep Agent over WhatsApp. It turned my resume and the two confirmed question types into a day-by-day schedule. It ran a quick mock on the buy/sell logic. That is where I caught the threshold-direction slip before the real test.

Days 1-3, Algorithmic and OOP drills

The first three days went to drilling buy/sell and time-series logic. I also practiced OOP shape-class drills, including area, perimeter, and aggregate statistics across a collection.

Those shapes match both the questions I saw and the three-subtest reports. The success check was solving each variant cold within twenty minutes. I did it without re-reading the prompt.

Days 4-5, SQL joins and REST API pagination

Days four and five went to SQL joins, aggregation, and window functions. I also did REST API pagination with page, per_page, data, and total_pages fields. These map directly to the SQL and API sub-tests that candidates report. So the drills stayed on target instead of wandering into unrelated tags.

Days 6-7, Timed simulation and proctoring-safe rule

I finished with a timed full simulation. I kept one rule I never broke: never run an invisible or overlay assist tool during the OA. The success check was completing a full timed set with no assist tool open. I skipped broad LeetCode-tag grinding and system-design prep. Neither showed up in the confirmed question set.

What Happens After You Submit the Palantir HackerRank OA

The confirmed signal

One candidate account describes the post-OA path. After the HackerRank test, they got a phone call that asked where their interests were. Then a rejection email. The process ran OA, then a phone screen, then a decision.

Reddit candidate reports sketch the fuller loop beyond that screen. The common shape is OA, then a recruiter call, then a technical interview, then a virtual onsite with a learning round and a decomposition round, then a hiring-manager round. Those later rounds use a live HackerRank CodePair, not the async OA. I did not go through these myself, so treat the sequence as reported, not confirmed by me.

What is unknown

The exact onsite tasks and the typical wait time are not something I verified. I can confirm the OA feeds into a phone screen from one account. The rest of the loop comes from other candidates' reports, which may differ by role and year.

FAQ

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

Desktop overlay tools put the AI's answer on your computer screen. They render it as a hidden layer above the browser through a basic OS trick. Proctoring software keeps adding detection as these tools spread. So the exposure is not fixed.

InterviewFox pushes the answer to your phone. That is a physically separate device. No screenshot or session monitoring can reach it by design. If you use AI help during the OA, the dual-device setup removes the answer from your screen entirely.

How many questions are on the Palantir HackerRank OA?

Palantir does not publish an official count. I solved two algorithmic problems. Multiple 2026 candidate reports describe the standard layout as three sub-tests: coding, SQL, and REST API. Treat that as the common pattern, not a guaranteed rule.

Is there a time limit on the Palantir HackerRank OA?

Palantir does not confirm the time limit publicly. Candidate reports usually describe a 90-minute window. HackerRank lets each company set the clock per test, so the real limit depends on how Palantir configured the instance.

How is the Palantir HackerRank OA scored?

HackerRank scores per test case or per problem. Some customers use scaled scores. No Palantir-specific pass score is published. So I cannot tell you the cutoff.

What happens after you submit the Palantir HackerRank OA?

One candidate reported an OA, then a phone screen about their interests, then a decision email. The full loop beyond the phone screen is not something I could verify.