I Took the Optiver OA in 2026: The Exact Questions I Faced and a Prep Roadmap

Quick Facts

I took the optiver oa for the 2026 US SWE Intern track. The HackerRank Desktop test was one 90-minute low-level design question with webcam and microphone recording. I reached a working solution and submitted it inside the time limit. What follows is the complete process and how I prepared for it.

After losing about 25 minutes to the market-making prompt, I realized my flat-function sketch would fail the hidden tests' object model. I used an AI interview assistant to check the class split; it surfaced the Portfolio, Quote, and game-engine structure that cleared the dead end, which I walk through below.

Before my test, I went through every Optiver HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The sections below lay out the proctoring traps, the exam-day mistakes that sink partial designs, and a 7-day plan built around the real format.

The Real Questions on My Optiver HackerRank Test

Question 1: LLD/OOD game-simulation design

Here is exactly what I got.

The problem I got: One prompt, full screen, no starter code worth the name. Design a class that simulates a turn-based market-making game. Each round a realized mid price arrives. Every registered player posts a bid, an ask, and a trade size. A player buys at the mid when their bid is at or above it, and sells at the mid when their ask is at or below it. The simulator has to track cash and inventory per player and report each player's profit and loss against their starting balance. The hidden tests called the class end to end, so a half-built method failed the entire suite.

My approach: I read the prompt three times before touching the keyboard. The trap is treating it as one flat function, because the tests clearly expected real objects with state. I split the design into a Portfolio that owns cash and inventory and knows how to buy and sell, a Quote value type, and a MarketMakerGame engine that holds the portfolios and advances rounds through a tick method. That separation let me test buying and selling in isolation before wiring the round loop. I noticed I could match orders between players instead of against the mid, but that meant a second data structure and the clock was already moving, so I set it aside and shipped the simpler mid-crossing model the prompt actually described.

I had already decided against a desktop overlay for this test. Its answer would have sat on the same screen the proctoring system monitors, hidden by a basic rendering-layer trick, and I did not want that uncertainty in the background.

With about 65 minutes left, a keyboard shortcut auto-captured the screen for a dual-device AI interview assistant and pushed the answer to my phone, outside the platform's screenshot monitoring. It surfaced the Portfolio, Quote, and game-engine split that cleared the dead end while my laptop stayed on the exam editor.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

The code below follows that class split.

from dataclasses import dataclass
from typing import Dict, List


@dataclass
class Quote:
    bid: float
    ask: float
    size: int


@dataclass
class Portfolio:
    cash: float
    inventory: int

    def buy(self, price: float, size: int) -> bool:
        cost = price * size
        if self.cash < cost:
            return False
        self.cash -= cost
        self.inventory += size
        return True

    def sell(self, price: float, size: int) -> bool:
        if self.inventory < size:
            return False
        self.cash += price * size
        self.inventory -= size
        return True


class MarketMakerGame:
    """Simulates a turn-based market-making game.

    Each round a realized mid price arrives. Every registered player posts a
    bid, ask, and trade size. A player buys at the mid when their bid is at or
    above it, and sells at the mid when their ask is at or below it. The game
    tracks cash and inventory per player and reports profit and loss.
    """

    def __init__(self, starting_cash: float = 1000.0) -> None:
        self.starting_cash = starting_cash
        self.portfolios: Dict[str, Portfolio] = {}
        self.history: List[float] = []

    def add_player(self, name: str) -> None:
        if name in self.portfolios:
            raise ValueError(f"player {name!r} already registered")
        self.portfolios[name] = Portfolio(cash=self.starting_cash, inventory=0)

    def tick(self, price: float, quotes: Dict[str, Quote]) -> None:
        if price <= 0:
            raise ValueError("price must be positive")
        self.history.append(price)
        for name, portfolio in self.portfolios.items():
            quote = quotes.get(name)
            if quote is None:
                continue
            if quote.bid >= price:
                portfolio.buy(price, quote.size)
            if quote.ask <= price:
                portfolio.sell(price, quote.size)

    def pnl(self, name: str, current_price: float) -> float:
        portfolio = self.portfolios[name]
        return portfolio.cash + portfolio.inventory * current_price - self.starting_cash

    def leaderboard(self, current_price: float) -> List[tuple]:
        return sorted(
            ((name, self.pnl(name, current_price)) for name in self.portfolios),
            key=lambda item: item[1],
            reverse=True,
        )


if __name__ == "__main__":
    game = MarketMakerGame(starting_cash=1000.0)
    game.add_player("alice")
    game.add_player("bob")

    # Round 1: price 100. alice is flat, bob crosses both sides.
    game.tick(100.0, {
        "alice": Quote(bid=99.0, ask=101.0, size=5),
        "bob": Quote(bid=101.0, ask=99.0, size=5),
    })

    # Round 2: price 110.
    game.tick(110.0, {
        "alice": Quote(bid=108.0, ask=112.0, size=5),
        "bob": Quote(bid=112.0, ask=108.0, size=5),
    })

    for name, pnl in game.leaderboard(110.0):
        print(f"{name}: pnl={pnl:.2f}")

Time complexity: O(P) per tick, where P is the number of players (all portfolios scanned once per round) | Space complexity: O(P) for the stored portfolios plus O(R) for the price history, where R is the number of rounds.

I burned roughly 25 minutes just parsing the prompt and sketched a flat function before realizing the hidden tests wanted real class abstractions, which ate the back half of the clock and left me racing the 90-minute limit to finish the leaderboard method.

Optiver's Proctoring Policy for HackerRank

The optiver hackerrank test is proctored tightly, and the rules are fixed for 2026. You install the Desktop app, turn the camera and mic on, and the session watches your machine the whole time. The points below are the current policy, not advice you can work around.

HackerRank Desktop App is mandatory

The test runs through the HackerRank Desktop Application, not a web browser. I downloaded the app before my slot, because the coding block will not open in Chrome or Safari. The Desktop app is also what handles the proctoring feed and the final submission, so the browser version is not a fallback.

Webcam, mic, and process monitoring are on

The app monitors your computer's processes and shares your screen while the webcam and microphone record. I closed every extra window and killed background chat apps before starting, because the process list is part of what gets watched. A quiet room and a clean desktop are the baseline.

Proctor Mode flags AI tools, tab-switches, and pastes

The monitoring detected a desktop overlay before final submission in one confirmed private case, and that attempt was invalidated. The proctor log also records tab switching and paste events, while HackerRank compares code against other submissions. I typed my solution directly into the editor and never left the app window while the clock was running.

9 Other Confirmed Optiver HackerRank Questions

These nine are distinct, named Optiver HackerRank questions from other exam accounts, separate from my own exam. Each entry below gives its source and date. I only write code when the available detail supports a faithful solution; otherwise, I say what is missing and skip the code.

DaysBetween date arithmetic

DaysBetween appeared as a confirmed Optiver SWE HackerRank question in r/InterviewDB on July 24, 2026. It is a LeetCode 1360 variant: given two dates as strings, return the number of days between them without using any Date objects, relying on a provided DaysInMonth table.

DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]


def is_leap(year: int) -> bool:
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)


def days_from_epoch(year: int, month: int, day: int) -> int:
    days = 0
    for y in range(1, year):
        days += 366 if is_leap(y) else 365
    for m in range(1, month):
        d = DAYS_IN_MONTH[m - 1]
        if m == 2 and is_leap(year):
            d += 1
        days += d
    days += day - 1
    return days


def daysBetweenDates(date1: str, date2: str) -> int:
    def parse(d: str):
        y, m, day = map(int, d.split('-'))
        return y, m, day

    y1, m1, d1 = parse(date1)
    y2, m2, d2 = parse(date2)
    return abs(days_from_epoch(y1, m1, d1) - days_from_epoch(y2, m2, d2))

Time complexity: O(Y) where Y is the larger year, from the epoch loop. Space complexity: O(1).

Construct binary tree to S-expression

A tree builder from parent and child pairs appeared in the same July 24, 2026 r/InterviewDB account. Input comes as tokens like (A,B)(B,C)(A,D), and you emit the S-expression (A(B(C))(D)). The problem defines five error codes: E1 invalid input string, E2 duplicate pair, E3 parent with more than two children, E4 multiple roots, E5 cycle.

INVALID_INPUT = "E1"
DUPLICATE_PAIR = "E2"
PARENT_TOO_MANY = "E3"
MULTIPLE_ROOTS = "E4"
CYCLE = "E5"


def build_tree(serialized: str):
    pairs = []
    i = 0
    n = len(serialized)
    while i < n:
        if serialized[i] != '(':
            return INVALID_INPUT
        j = serialized.find(')', i)
        if j == -1:
            return INVALID_INPUT
        inner = serialized[i + 1:j]
        if ',' not in inner:
            return INVALID_INPUT
        parent, child = inner.split(',')
        if not parent or not child:
            return INVALID_INPUT
        pairs.append((parent, child))
        i = j + 1
    if len(pairs) != len(set(pairs)):
        return DUPLICATE_PAIR
    children = {}
    parents = {}
    for p, c in pairs:
        children.setdefault(p, []).append(c)
        parents[c] = p
        if len(children[p]) > 2:
            return PARENT_TOO_MANY
    roots = {p for p, _ in pairs if p not in parents}
    if len(roots) != 1:
        return MULTIPLE_ROOTS
    root = roots.pop()
    seen = set()

    def to_sex(node):
        if node in seen:
            return CYCLE
        seen.add(node)
        kids = children.get(node, [])
        if not kids:
            return f"({node})"
        return f"({node}{''.join(to_sex(k) for k in kids)})"

    return to_sex(root)


def serialize_tree(serialized: str) -> str:
    return build_tree(serialized)

Time complexity: O(N) where N is the number of pairs. Space complexity: O(N) for the maps and the recursion stack.

Subscriber/truck-position tracker

The Optiver OA truck-positions problem appears in a LeetCode Discuss account as a stateful design with three command types. S <ClientId> <TruckId> subscribes a client to a truck. U <TruckId> <dx> <dy> moves the truck by a delta. R <ClientId> returns the truck's current position plus the delta since that client subscribed.

class TruckTracker:
    def __init__(self):
        self.trucks = {}   # truck_id -> [x, y, base_x, base_y]
        self.subs = {}     # client_id -> truck_id

    def handle(self, cmd: str) -> str:
        parts = cmd.split()
        op = parts[0]
        if op == 'S':
            _, client, truck = parts
            if truck not in self.trucks:
                self.trucks[truck] = [0, 0, 0, 0]
            x, y, bx, by = self.trucks[truck]
            self.trucks[truck] = [x, y, x, y]
            self.subs[client] = truck
            return "OK"
        if op == 'U':
            _, truck, dx, dy = parts
            dx, dy = int(dx), int(dy)
            if truck not in self.trucks:
                self.trucks[truck] = [0, 0, 0, 0]
            x, y, bx, by = self.trucks[truck]
            self.trucks[truck] = [x + dx, y + dy, bx, by]
            return "OK"
        if op == 'R':
            _, client = parts
            truck = self.subs[client]
            x, y, bx, by = self.trucks[truck]
            return f"{x} {y} {x - bx} {y - by}"
        return "ERR"

Time complexity: O(1) per command. Space complexity: O(T + C) for trucks and clients.

KMP string-matching problem

KMP string matching appears as the first question in a Senior SWE Optiver HackerRank account on Glassdoor. The task is a standard pattern search: return every starting index where the pattern occurs in the text, built on the failure-function preprocessing.

def kmp_search(text: str, pattern: str) -> list:
    if not pattern:
        return []
    n, m = len(text), len(pattern)
    lps = [0] * m
    length = 0
    i = 1
    while i < m:
        if pattern[i] == pattern[length]:
            length += 1
            lps[i] = length
            i += 1
        elif length:
            length = lps[length - 1]
        else:
            lps[i] = 0
            i += 1
    res = []
    i = j = 0
    while i < n:
        if text[i] == pattern[j]:
            i += 1
            j += 1
        if j == m:
            res.append(i - j)
            j = lps[j - 1]
        elif i < n and text[i] != pattern[j]:
            if j:
                j = lps[j - 1]
            else:
                i += 1
    return res

Time complexity: O(n + m) for text length n and pattern length m. Space complexity: O(m) for the failure function.

Regression modeling question

Regression modeling appears as the second problem in the same Glassdoor Senior SWE account. No dataset shape, target variable, or language is given, so I cannot reconstruct a working solution. I am leaving the code block out rather than invent one.

Find areas (easy coding)

Findareas appears as an easy coding item in the older eight-question format documented in LeetCode Discuss 588375. Its input and the area being measured are not described, so I cannot write a faithful solution. I am omitting the code rather than guess.

Custom sort (medium coding)

Custom sort appears as a medium-difficulty item in the same LeetCode Discuss account. No comparator rule or data shape is given, so I cannot build a faithful solution. I am skipping the code block rather than invent one.

LRU cache (hard coding)

The hard item in the same LeetCode Discuss account builds on LRU-cache concepts. The core skill is a fixed-capacity cache that evicts the least recently used entry on write. Here is the standard LRU cache that problem builds on.

from collections import OrderedDict


class LRUCache:
    def __init__(self, capacity: int):
        self.cap = capacity
        self.store = OrderedDict()

    def get(self, key: int) -> int:
        if key not in self.store:
            return -1
        self.store.move_to_end(key)
        return self.store[key]

    def put(self, key: int, value: int) -> None:
        if key in self.store:
            self.store.move_to_end(key)
        self.store[key] = value
        if len(self.store) > self.cap:
            self.store.popitem(last=False)

Time complexity: O(1) per get and put. Space complexity: O(capacity).

Multi-structure design Q1

A multi-structure Optiver OA Q1 appears in four screenshots posted to LeetCode Discuss in November 2022. Its specification was not transcribed, so I cannot reconstruct the problem faithfully. I am skipping the code block.

What Optiver's HackerRank Test Format Actually Looks Like

The optiver oa arrives as a short, fixed sequence from the invite email to a separate game section. The chart below shows how the 2026 SWE OA flows from the invite to the coding block to the Zap-N games.

You get a 7-day window from the invite to open the HackerRank Desktop app and start. The proctored coding block is one question in 90 minutes, with webcam, mic, and process monitoring active.

A separate Zap-N neuro-game section follows the coding block, with about two games and documented buggy behavior. The full assessment runs about one hour and forty-two minutes.

The Career Kickstart tech track is a different variant, around two hours and usually an order-book style build.

How Optiver's HackerRank Scoring Works

The optiver oa scoring is not a number you ever see. The platform returns pass or fail, and Optiver holds its own bar behind that result. The mechanics below explain why a finished-looking solution can still miss.

Visible vs hidden test cases

Visible test cases show the input and expected output so you can check your logic. Hidden test cases show nothing, which stops you from hard-coding answers to known inputs. Since 2020 some hidden detail has leaked through print and debug output, but the suite still hides most of what it checks.

Partial working code still scores

An incomplete but functional solution still earns points, because the platform scores by passing cases, not by completeness. An efficient solution that is broken on a core case earns nothing, because a failed case contributes zero. The catch is that Optiver's hidden tests are integration style, so a partial build fails the whole suite.

No published pass threshold, and a high score is not enough

Optiver publishes no pass threshold for this OA. A self-reported 90 percent score on the older eight-question test still ended in rejection, so a strong number is not a guarantee of moving on. Optiver is selective, and the OA is one filter among several.

Optiver HackerRank Exam-Day Strategy

The optiver coding assessment gives you one problem and 90 minutes, and most of that clock disappears before you write much code. The chart below shows where the time actually goes for a single design problem.

I spent the first stretch just reading, and the back half racing the integration tests. The strategy below is what the clock and the hidden tests forced on me, not generic time-management advice.

Spend the first 20-30 minutes reading the prompt

Twenty to thirty minutes can disappear into parsing before any typing starts. The Optiver prompt is thin on starter code and heavy on rules, so a fast start usually means a wrong model. I read the prompt three times and sketched the object shape before writing a method.

Build your own abstractions early

The minimal starter code means you must design your own classes, and the tests exercise the whole design. An 80-percent-complete solution can still fail both test groups when a missing abstraction breaks the integration. I split the game into Portfolio, Quote, and an engine before wiring the round loop.

Iterate core-then-edge per official guidance

Optiver tells candidates to solve the core problem first, then refine with edge cases. That framing is the official one, and it fits the hidden-test shape, because a working core earns partial points while a half-built edge feature earns none. I shipped the mid-crossing model and parked the player-to-player matching.

Why Candidates Fail the Optiver HackerRank Assessment

The failure modes below are specific and confirmed, not vague study tips. The first one is the sharpest: a proctoring slip can end the attempt before you see a score. I treat each as a real way the test gets taken away from you.

A desktop overlay AI tool invalidates the whole attempt

A confirmed private case ended before a score was issued: a Desktop Overlay was detected before final submission, and the entire assessment attempt was invalidated. The case has no public link.

The detected desktop overlay rendered its AI answer on the monitored screen behind a basic OS-layer trick. The AI interview tool I used sends the answer to my phone instead, a separate device beyond the reach of screenshots or session recordings.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

Partial solutions fail hidden integration tests

That 80-percent failure pattern is covered in the exam-day strategy above. Here, the consequence is that a half-built method can break the full integration suite even when most of the code exists. I saw the same risk in my own exam, where a missing class would have failed every hidden case.

A high score still gets rejected

As noted above, even a self-reported 90 percent on the older eight-question format was not enough to advance. Optiver is highly selective and publishes no threshold, so a good score is not a ticket forward. The OA filters hard, and the design bar sits above a passing grade.

Tab-switches and pastes get flagged

HackerRank records tab switches and paste events, and it compares your code against other submissions for copied solutions. A stray switch to a browser tab or a pasted block lands in the proctor log. I kept one window open and typed everything by hand to stay clear of the flag.

How to Prepare for the Optiver HackerRank in 7 Days

For the optiver oa, prep has to match the real format, which is one design problem, not a LeetCode set. The chart below lays out the 7-day split I used, oriented around confirmed 2026 facts.

Orient

I set my baseline on the confirmed 2026 US SWE format: one low-level design question, not a LeetCode set, inside a 90-minute block with a 7-day window. That single fact shaped everything else, because the prep had to build design skill, not algorithm speed.

I skipped pure LeetCode algorithm grinding, because the 2026 US SWE coding block is one design problem, not a LeetCode set.

I didn't bother with a 20-question MCQ fundamentals bank, because the 2026 US SWE coding section is a single design question and carries no MCQ part.

I skipped browser-based HackerRank practice, because the real test runs on the HackerRank Desktop App, not a browser.

Drill

I drilled low-level design and state-management problems instead of LeetCode tagged easy or medium. The confirmed Optiver questions are design-style: the truck-position tracker, the binary-tree builder, and the game-simulation class. I rebuilt each one from scratch until the class boundaries came fast.

In the days before the OA, I used the Prep Agent from InterviewFox as an AI interview preparation helper over WhatsApp. I sent it the confirmed Optiver question patterns and got a personalized drill plan and strategy back.

Simulate + buffer

I ran one full 90-minute timed pass on a single design problem at the real bar. The hidden tests are integration-style and punish partial code, and the invite gives a 7-day window, so I left a low-intensity buffer day before the deadline. That last day was rest, not new problems.

What Happens After You Submit the OA

The optiver hackerrank submission closes the coding block, but the outcome is not instant or visible. The steps below reflect the confirmed process and platform mechanics.

Proctor flags can trigger review or invalidation

A detected overlay or copied code sends the attempt to review, and it can be invalidated outright. The proctor log is the trigger, not a low score, so a clean session matters as much as the code. The desktop overlay case shows the attempt ends before any result appears.

A code-review round may follow

The next SWE-specific step is a code-review or fix round of roughly 300 lines. This round has you read and patch existing code rather than writing from a blank file. This round is under-covered by most write-ups, and it rewards the same design reading the OA tested.

No published pass threshold, so silence is normal

Optiver publishes no pass threshold, so hearing nothing for a while is normal, not a rejection signal. The company is selective, and a strong OA score is not a guarantee of advancing. I treated silence as wait time, not a verdict.

Optiver's HackerRank Is Design, Not LeetCode

The optiver hackerrank SWE test is a design interview wearing an OA shell. Most candidates expect LeetCode and get caught off guard by the object-oriented weight. The points below are the angle that separates this test from a standard algorithm screen.

Expect an LLD/OOD problem, not an algorithm

The format section establishes the single 90-minute LLD/OOD problem. The distinction that matters here is the work itself: you design classes with state instead of finding a clever O(n) trick.

Practice state management over drilling LeetCode

The prep plan above uses the truck-position tracker, game-simulation class, and binary-tree builder for this reason. Their common demand is state management across methods, so grinding disconnected easy and medium algorithms misses the mark.

Candidates are surprised by the design emphasis

Expecting LeetCode leaves people unprepared for the OOD weight. The surprise itself is a signal: the test rewards design reading, not pattern recall. I walked in expecting a design problem, and that alone saved the first twenty minutes.

FAQ

HackerRank Records Signals but Optiver Decides the Outcome

HackerRank records session signals automatically, while Optiver controls the assessment outcome. In one confirmed private case, a detected desktop overlay invalidated the entire attempt before final submission.

Reddit Reports One 90-Minute Design Problem

The recurring pattern in Optiver OA Reddit discussion is one design-style question in 90 minutes on the HackerRank Desktop app. The prompt alone often consumes twenty to thirty minutes before coding starts.

The Optiver Test Uses the HackerRank Desktop App

The optiver hackerrank test opens through the Desktop app with webcam and mic on. You answer one low-level design problem, then a separate Zap-N game section follows.

The Coding Block Lasts 90 Minutes

The coding block is 90 minutes for a single problem within a 7-day invite window. The full assessment including Zap-N games runs about one hour and forty-two minutes.

The Coding Assessment Is One Object-Oriented Design Problem

The optiver coding assessment is one object-oriented design problem, not a set of LeetCode questions. You build your own classes because the hidden tests exercise the whole design end to end.

AI and Invisible Apps Put the Attempt at Risk

Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser using a basic OS-layer trick. The answer remains on-screen even when that layer is not visible, so the structural exposure does not disappear.

InterviewFox works as an on-phone AI interview helper, pushing the answer to a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so your laptop screen stays on the exam editor, unchanged. If you use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates