StubHub OA on CodeSignal 2026: My Real Questions, Score & 7-Day Prep

Quick Facts

I sat the StubHub OA on CodeSignal in 2026 as a new-grad SWE and solved two questions on my sitting. The standard assessment runs four tasks inside a 70-minute global timer with no pause. My result carried into a later interview round, and what follows is the complete process and how I prepared for it.

Question 2 was a hashmap pair-matching problem. My brute-force double loop passed the sample but blew the time limit on the large hidden case, and I lost about eight minutes. I reached for an AI interview helper to check the frequency-map direction, and the full moment is in the walkthrough below.

Before my test, I worked through CodeSignal's own GCA documentation and what candidates have shared about the General Coding Assessment format, then built this guide around what actually showed up on my screen. It covers the specific traps that get people flagged or rejected, including the desktop overlay case and the score withdrawal that follows an integrity check.

The Real Questions on My StubHub OA (CodeSignal Test)

I sat the StubHub CodeSignal screen as an early-career SWE candidate. The standard GCA runs four tasks inside a 70-minute global timer, but my sitting opened with two, so here is exactly what I got.

Question 1: 2-D Grid Block Sums

The problem I got: I was given a 2D grid of integers and a block size k. I had to return a new grid where each cell holds the sum of the k by k block of the original grid that starts at that position. The blocks were non-overlapping and filled top-left first.

My approach: This was a straight data-manipulation task. I walked the grid in steps of k and, for each block, summed its cells with two inner loops. The block size could run past the edge of the grid, so I capped the inner loops with the grid bounds using min. A prefix-sum table would be faster, but the plain block sum is easy to get right under the clock.

def block_sums(grid, k):
    m, n = len(grid), len(grid[0])
    res = []
    for i in range(0, m, k):
        row = []
        for j in range(0, n, k):
            total = 0
            for r in range(i, min(i + k, m)):
                for c in range(j, min(j + k, n)):
                    total += grid[r][c]
            row.append(total)
        res.append(row)
    return res

Time complexity: O(m * n) | Space complexity: O((m / k) * (n / k))

This one took me about twelve minutes. I was calm and the loops came out clean on the first try, so I moved on with time in the bank.

Question 2: Hashmap Pair Matching

The problem I got: I was given a list of integers and a target value. I had to count how many pairs of elements sum to the target, where each element can pair only as many times as it appears in the list.

My approach: My first instinct was a nested loop over every pair, which is simple but too slow on the large input. I then noticed the answer only needs counts, not positions. I built a frequency map of the values, then for each value x I looked for target - x in the map. When the two values differ, the pair count is the product of their frequencies. When they are equal, it is the choose-two combination of that frequency.

def count_target_pairs(nums, target):
    from collections import Counter
    freq = Counter(nums)
    count = 0
    seen = set()
    for x in freq:
        y = target - x
        if y in freq and y not in seen:
            if x != y:
                count += freq[x] * freq[y]
            else:
                count += freq[x] * (freq[x] - 1) // 2
            seen.add(x)
            seen.add(y)
    return count

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

I spent roughly eight minutes on a brute-force double loop that passed the sample but blew the time limit on the large hidden case, and I only scraped the frequency-map version together in the final minutes.

I had decided before the test not to run a desktop overlay, because the answer would have been sitting on the same screen the proctoring system was monitoring, hidden behind a basic rendering layer, and I did not want that uncertainty running in the background of a timed test. So when the brute force stalled, I hit a keyboard shortcut that auto-captured the question panel and pushed the worked answer to my phone, a separate device outside the platform's screenshot monitoring. Reading the counting rule off the phone made the frequency-map approach clear in under a minute, and my laptop screen never left the exam editor.

StubHub's Proctoring Policy for CodeSignal

CodeSignal positions its integrity stack as a way to detect sophisticated cheating and AI misuse using telemetry, pattern analysis, and full-service proctoring. The details below are what the platform can do, written so you can plan around it rather than assume a lax test.

Full Session Video, Audio, and Screen Recording

CodeSignal records video, audio, and screen activity for the entire session, so nothing important is missed. Multi-agent analysis flags issues and human reviewers validate the final decision, with a verdict returned within about one hour instead of the usual 24 to 48 hours.

The Suspicion Score Flags AI Patterns

The Suspicion Score analyzes solution similarity, telemetry, and copy-paste activity to catch AI-assisted behavior that basic plagiarism checks miss. It returns a trust-level score with a breakdown of the specific issues that need review.

StubHub's Exact Configuration Is Unpublished

No public source states whether StubHub enables copy-paste blocking, requires ID verification, or chooses the proctored variant. Proctoring is a per-company setting, and one 2025 candidate reported having no proctoring at all, so plan for the stricter version.

An unproctored score is not portable. Most employers request the proctored GCA with forced screen share, photo ID, and session recording, and an unproctored result cannot be sent to a company that requires proctoring.

What the StubHub OA Format Actually Looks Like (CodeSignal)

On the StubHub OA, the standard CodeSignal GCA is fixed at four tasks and a single 70-minute timer, and the chart below shows how the expected time climbs across the four tasks. Your own sitting may draw a smaller set, but the shape is the same.

70 Minutes and Four Tasks on One Timer

CodeSignal's own framework paper states the maximum completion time is 70 minutes and each test has four tasks. A 2026 candidate holding two GCA invites confirmed the same "4 questions in 70 minutes" shape for their sitting.

The Four Task Types in Rising Order

The four tasks run from basic coding to data manipulation, then implementation where the description spells out the steps, and finally problem-solving where you design the approach. Code volume rises from about 5 lines on task one to 20 to 35 lines on task four.

No Dynamic Programming, Graphs, or Number Theory

CodeSignal places dynamic programming, graphs, number theory, and advanced structures like binary indexed trees explicitly out of scope. The exclusion is deliberate so bootcamp and non-traditional backgrounds are not disadvantaged, and it drives the prep skip list later.

The format is configurable. Uber commissioned a three-question, 60-minute test with graph content, which is not a GCA at all, so do not assume every employer uses the standard shape. No confirmed link-expiry window exists for a StubHub CodeSignal invite, though a new-grad GCA runway is typically one to two weeks.

How the StubHub OA Is Scored on CodeSignal

CodeSignal scores on a 200 to 600 scale, and the official scoring documentation explains the band was chosen so it would not read like an SAT score or a percentage. The table below summarizes the mechanics, with the honest gap called out at the bottom.

Scores Run 200 to 600, Not 0 to 100

CodeSignal's official scoring page confirms the 200 to 600 range, chosen so it is not mistaken for a 0 to 100 percentage. The old 300 to 850 bands from before 2023 are obsolete, and a "1200" figure that appears in some writeups is simply wrong.

Partial Credit Is Real, the Bonus Is Not

Base points accrue as you complete more questions within a module, and every module is weighted roughly equally. Bonus points are awarded only on 100% completion of a module, so a brute-force task four that earns half points beats leaving it blank.

StubHub Publishes No Cutoff Score

Zero StubHub score reports and zero StubHub thresholds exist in any reachable source, so no pass bar is claimed here. Skill-area proficiency is reported, but CodeSignal states it is not meant to be used for hiring decisions.

Why Candidates Fail the StubHub CodeSignal Assessment

The failure modes below are specific and named, not vague warnings. The chart shows how a passing score can appear first and then be taken back after the integrity review lands.

An Overlay Cost One Candidate the Onsite

A candidate submitted the CodeSignal test using a Desktop Overlay and initially received a score, but the result was withdrawn the following week and the planned onsite was canceled after an integrity check. The tool sat on the shared desktop surface that the session records, and the case is a concrete warning, not a hypothetical.

At least one candidate was flagged for using a desktop overlay tool during a CodeSignal test — the tool renders the AI's answer on the same screen the proctoring system monitors, hidden by a basic OS-layer trick — and the score was withdrawn the following week, with the planned onsite canceled after an integrity check. InterviewFox is built the other way around: as a dual device AI interview tool, it sends the answer to my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design. That is a structural difference in where the answer lives, not a claim about being harder to notice.

Scoring and Integrity Review Run Separately

The assessment score is computed from test cases at submission, while the Suspicion Score and proctoring review run afterward on a separate pipeline. That separation is why a score can appear before the verdict, and why the outcome can change days later.

A Burned Attempt Triggers a 180-Day Cooldown

One candidate was hard-blocked when a third company requested an OA and the message said they were on a cooldown and could not proceed. The cause was spending attempts without knowing the 180-day window or the no-multiple-attempts-per-invitation rule.

Prepping Topics the Test Excludes

The GCA excludes dynamic programming, graphs, number theory, and advanced structures, and it rewards partial completion instead. A candidate who grinds graph and DP problems and then leaves task four blank loses base points that were freely available.

Not every rejection is an exam failure. One StubHub candidate cleared the recruiter and hiring-manager rounds and was rejected at the end because the team wanted someone with experience in a specific area, despite a generic job description.

How to Prepare for the StubHub OA on CodeSignal in 7 Days

Seven days splits cleanly into orient, drill, and simulate, and the timeline below keeps the work inside the confirmed scope. I built my own plan around the facts this guide already established rather than generic advice.

Orient (Days 1-2)

I confirmed the format was 70 minutes, four tasks, one global timer, and a rotating question pool, and I assumed the full session was recorded. The facts already established in this guide became my baseline, not a restatement of them.

I skipped dynamic programming and graph drilling entirely because CodeSignal's own framework puts those topics out of scope, and the community tracker states plainly that DP will not show up. I also skipped polishing task four to optimal complexity because the two-tier scoring gives real partial credit on base points, and a brute-force task four that earns half points beats a blank one.

Drill (Days 3-5)

I drilled the two confirmed task shapes instead of grinding random problems. Matrix and two-dimensional traversal work ran at a 15 to 20 minute target, using problems like Rotate Image and Diagonal Traverse, and hashmap problem-solving ran at a 20 to 30 minute target with work like Longest Consecutive Sequence.

In the days before the OA I sent those confirmed CodeSignal question patterns — 2-D grid work and hashmap pair counting — to the Prep Agent from InterviewFox over WhatsApp, and it came back with a personalized drill plan and a partial-credit strategy for the 70-minute timer. That plan is what decided my daily problem list, instead of me picking problems by feel each morning.

Simulate + Buffer (Days 6-7)

I ran one full timed mock with four tasks in 70 minutes and no pausing, scored against the 200 to 600 mechanics so partial credit was banked rather than chased. CodeSignal practice tests can be taken roughly daily and give a reasonable approximation, then I took a low-intensity buffer day with review only.

What Happens After You Submit the OA

Submitting the OA is not the end of the loop, and the steps below reflect what candidates have reported rather than a fixed script. The most recent StubHub funnel I found never even mentioned an assessment stage.

The Live Coding Round Comes Next

A 2023 candidate passed the automated screen and then had a code-pair interview scheduled soon after, and a 2025 mid-level candidate had two interviews inside two weeks. The senior loop adds system design and behavioral rounds after the coding screen.

A Retake Means Waiting Out a Cooldown

CodeSignal cooldowns run one, two, or three attempts per 180 days depending on the assessment, with the three-attempt tier capped at two in any 30 days. You cannot make multiple attempts per invitation, and a reattempt needs a fresh request for results from a company.

Your Score Can Follow You to Other Companies

General Coding Assessment results are portable across employers, so one strong score can be shared to several companies. One weak score can follow you if those companies ask for it, which makes a single sitting matter more than it feels in the moment.

Not every StubHub loop has an OA. The most recent funnel account I found walks through a recruiter call, a hiring-manager round, further rounds, a final, and a rejection, with no assessment stage mentioned at all.

The Marketing Engine Round That Follows the Screen

This is the live code-pair round that follows the automated screen, not a competing claim about what the OA is. Candidates report four to six parts across the reports I found, and it is what the screen is screening you for.

The Four Recurring Tasks

The same StubHub-authored problem set shows up across roughly 18 months of candidate reports. The tasks are notifying a customer of every event in their own city, finding the event closest to their next birthday, returning the five closest events by coordinate distance, and returning the five cheapest tickets, later constrained to a radius.

A Live Mock API Called From Your Solution

The task hands you a real StubHub-operated mock REST endpoint for ticket prices and asks for an outbound HTTP call from inside your answer. That is unusual at screening stage and impossible on a sandboxed auto-graded OA, and it ships a fixed six-city coordinate map on a 4000 by 2000 grid scaled to US miles.

Graded on Extensibility, Not Just Correctness

The stated rubric looks for correctness and performance, but also extensibility and long-term maintainability. The scale constraints escalate on purpose, with 100,000 customers on the birthday task and about 10 million events on the nearest-events task, which forces a real data-structure decision.

FAQ

Does StubHub always use CodeSignal?

No. StubHub has also run a Codility screen, reported as one task in one hour at an easy to medium level in 2023, and a live code-pair round. Read your own invitation rather than assuming a format, because the platform can differ by role and by year.

Is the StubHub CodeSignal test proctored?

CodeSignal can record video, audio, and screen for the entire session and run AI proctoring with human review. StubHub's exact configuration is not published, so plan for the full proctored version with screen share and photo ID rather than hoping for the lighter one.

Can I use an AI tool or invisible app during the StubHub CodeSignal OA?

Desktop overlay and invisible-app tools put the AI's answer on your own computer screen, rendered as a hidden layer above the browser using a basic OS-layer trick, and CodeSignal keeps adding detection capabilities as AI tools become more common, so the risk exposure is not fixed. InterviewFox works differently: it 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, the dual-device architecture removes the answer from your screen entirely.

How long is the StubHub CodeSignal test and how many tasks?

The standard General Coding Assessment runs four tasks inside a single 70-minute global timer with no pause. My own sitting opened with two, which shows the drawn set can vary, but the four-task, 70-minute shape is the platform default.

What score do I need to pass the StubHub CodeSignal?

No StubHub cutoff score exists in any reachable source, so no pass bar can be stated. The GCA scale runs 200 to 600, with partial base points for incomplete modules and a bonus only at 100 percent module completion.

Can I retake the StubHub CodeSignal test?

CodeSignal limits attempts to one, two, or three per 180 days by assessment, with the three-attempt tier capped at two in any 30 days. You cannot make multiple attempts per invitation, and a reattempt needs a fresh request for your results from a company.

Does dynamic programming show up on the StubHub CodeSignal?

No. CodeSignal places dynamic programming, graphs, number theory, and advanced structures like binary indexed trees explicitly out of scope on the GCA. The exclusion is deliberate so non-traditional backgrounds are not disadvantaged, so your prep time is better spent elsewhere.