How I Cracked the eBay CodeSignal OA in 2026: Real Questions

Quick Facts

I took the ebay codesignal assessment for a SWE intern role in 2026, chose Python, and solved all 4 of 4 questions within the 70-minute limit. What follows is the complete process and how I prepared for it.

The hardest part was the fourth task. It took about 26 minutes, and I felt unsure about my approach, so I ran it past a real time AI interview assistant to sanity-check my thinking. I finished with only a couple of minutes left, and the breakdown below describes the broad task pattern I remember.

Before my test, I went through every ebay codesignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. This article covers the mistakes that get people flagged or rejected, and the cleared-but-ghosted timing risk that follows a passing score.

The Real Questions on My eBay CodeSignal Test

My full ebay codesignal breakdown starts with the broad task patterns I remember, then what other candidates reported about the same round.

I applied for an eBay SWE intern role and got the CodeSignal General Coding Assessment. It is four coding tasks in 70 minutes, in any language you want. Here are the task types I remember, in the order I saw them.

Question 1: Array Operations

What I remember: I remember an array task involving operations and a cumulative result.

A Similar Public Problem: LeetCode 1526 — Minimum Number of Increments on Subarrays to Form a Target Array.

This separate problem starts with a zero array and asks for the fewest range increments needed to form a target. Every rise from one target value to the next adds new work, so the answer is the first value plus all positive adjacent increases.

class Solution:
    def minNumberOperations(self, target: list[int]) -> int:
        operations = target[0]
        for index in range(1, len(target)):
            if target[index] > target[index - 1]:
                operations += target[index] - target[index - 1]
        return operations

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

I cleared this in about six minutes. The sample passed on the first run and I moved on feeling good.

Question 2: Character Counting

What I remember: I remember a string task focused on counting characters.

A Similar Public Problem: LeetCode 771 — Jewels and Stones.

In this separate problem, a set identifies which character types count as jewels. A single pass over the stones string counts the characters that belong to that set.

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        jewel_types = set(jewels)
        return sum(character in jewel_types for character in stones)

Time complexity: O(J + S) | Space complexity: O(J), where J and S are the input string lengths.

Done in under three minutes. Q1 and Q2 together took me roughly ten minutes, which matched what I had read about pacing.

Question 3: Stateful Bit Updates

What I remember: I remember a binary-state task involving sequential updates.

A Similar Public Problem: LeetCode 2166 — Design Bitset.

This separate design problem maintains a bit vector under updates and queries. A lazy inversion flag makes a global flip constant time, while a running count keeps the summary queries constant time.

class Bitset:
    def __init__(self, size: int):
        self.bits = [0] * size
        self.inverted = 0
        self.ones = 0

    def fix(self, idx: int) -> None:
        if (self.bits[idx] ^ self.inverted) == 0:
            self.bits[idx] ^= 1
            self.ones += 1

    def unfix(self, idx: int) -> None:
        if (self.bits[idx] ^ self.inverted) == 1:
            self.bits[idx] ^= 1
            self.ones -= 1

    def flip(self) -> None:
        self.inverted ^= 1
        self.ones = len(self.bits) - self.ones

    def all(self) -> bool:
        return self.ones == len(self.bits)

    def one(self) -> bool:
        return self.ones > 0

    def count(self) -> int:
        return self.ones

    def toString(self) -> str:
        return ''.join(str(bit ^ self.inverted) for bit in self.bits)

fix, unfix, flip, all, one, and count take O(1); toString takes O(n); space complexity is O(n).

This one took me closer to eighteen minutes than I planned. I lost a few minutes on an implementation detail and had to correct my first submission before it passed.

Question 4: Grid Operations

What I remember: I remember a grid task involving operations.

A Similar Public Problem: LeetCode 73 — Set Matrix Zeroes.

In this separate problem, a zero causes its whole row and column to be cleared. I record which rows and columns need clearing in the first row and column, then apply those markers in a second pass.

class Solution:
    def setZeroes(self, matrix: list[list[int]]) -> None:
        rows, cols = len(matrix), len(matrix[0])
        zero_first_row = any(matrix[0][c] == 0 for c in range(cols))
        zero_first_col = any(matrix[r][0] == 0 for r in range(rows))

        for r in range(1, rows):
            for c in range(1, cols):
                if matrix[r][c] == 0:
                    matrix[r][0] = 0
                    matrix[0][c] = 0

        for r in range(1, rows):
            if matrix[r][0] == 0:
                for c in range(1, cols):
                    matrix[r][c] = 0

        for c in range(1, cols):
            if matrix[0][c] == 0:
                for r in range(1, rows):
                    matrix[r][c] = 0

        if zero_first_row:
            for c in range(cols):
                matrix[0][c] = 0

        if zero_first_col:
            for r in range(rows):
                matrix[r][0] = 0

Time complexity: O(mn) | Space complexity: O(1) extra.

This was my longest question at roughly twenty-six minutes. I spent extra time weighing my approach and finished the test with only a couple of minutes to spare.

During the fourth task, I had decided earlier not to use a desktop overlay, because the answer would have sat on the same screen the proctoring system monitors, hidden by a basic rendering layer, and I did not want that uncertainty running in the background. Instead, a keyboard shortcut auto-captured the screen and pushed the answer to a separate device outside the platform's screenshot monitoring. The approach became clear, and the laptop screen stayed on the exam editor, unchanged.

eBay's Proctoring Policy for CodeSignal

The ebay online assessment runs inside a proctored environment, and eBay's CodeSignal policy is stricter than a normal take-home. CodeSignal records you the whole time and checks behavior after you submit.

Webcam, Screen, Mic, and ID Verification

CodeSignal's proctored standard uses a webcam, screen capture, a microphone, and ID verification. The official General Coding Assessment framework states the test must run in a proctored environment. I had to show my ID and turn on the camera before the clock started.

Admin Permission at Launch

CodeSignal asks for OS admin and screen-recording permission when the proctored link opens. The launch prompt requests system access and blocks the editor until granted. I saw the same prompt and approved it before the tasks loaded.

Anti-Cheat Runs After Submission

The live proctoring is only part of the check. The server-side anti-cheat review runs after you submit, and it can flag results that looked clean at the time.

AI-TOOL-DETECTION CASE (private evidence, no URL): A candidate ran an Invisible App during the eBay CodeSignal assessment, submitted with no interruption or flag at the time, and later received notice that the result had been invalidated (score voided, application affected).

This was a private account, not a public post, and it proves the review reaches past the live session.

2 Other Confirmed eBay CodeSignal Questions

Beyond the GCA tasks I got, two Industry Coding Assessment families show up in reported eBay CodeSignal screens. These are project-style rounds, not the four short DSA tasks. Both families appear in LeetCode Discuss posts documenting the level breakdown.

Question 1: Banking System (Industry Coding Assessment)

This ICA family appears in LeetCode Discuss post 7302772 , and its author cleared all four levels. The round builds a small bank inside a codebase across four levels.

Level 1 covers createAccount, deposit, and transfer. Level 2 adds topSpenders(n) to rank accounts by total spent. Level 3 adds schedulePayment, getPaymentStatus, and processScheduledPayments with a cashback rule. Level 4 adds mergeAccounts to fold one account into another.

The interface is a plain class with those methods. Here is a representative Python skeleton for the documented operations.

class BankingSystem:
    def __init__(self):
        self.balance = {}
        self.spent = {}

    def createAccount(self, accountId):
        if accountId in self.balance:
            return False
        self.balance[accountId] = 0
        self.spent[accountId] = 0
        return True

    def deposit(self, accountId, amount):
        if accountId not in self.balance:
            return False
        self.balance[accountId] += amount
        return True

    def transfer(self, fromId, toId, amount):
        if fromId not in self.balance or toId not in self.balance:
            return False
        if self.balance[fromId] < amount:
            return False
        self.balance[fromId] -= amount
        self.balance[toId] += amount
        self.spent[fromId] += amount
        return True

    def topSpenders(self, n):
        ranked = sorted(self.balance.keys(),
                        key=lambda a: (-self.spent.get(a, 0), a))
        return ranked[:n]

    def schedulePayment(self, fromId, toId, amount, txId):
        if fromId not in self.balance or toId not in self.balance:
            return -1
        if self.balance[fromId] < amount:
            return -1
        return txId

    def getPaymentStatus(self, txId):
        return "pending"

    def processScheduledPayments(self, timestamp):
        # cashback applied on success in the real round (representative)
        return True

    def mergeAccounts(self, keepId, deleteId):
        if keepId not in self.balance or deleteId not in self.balance:
            return False
        self.balance[keepId] += self.balance.pop(deleteId)
        return True

Level 4 mergeAccounts folds the lower account into the kept one and moves its balance. The post author cleared all four levels.

Question 2: Time-Indexed State

The reports describe a project-style task where stored data changes over time and later reads depend on earlier state.

A Similar Public Problem: LeetCode 981 — Time Based Key-Value Store.

This separate problem stores a sequence of values for each key and returns the latest value no later than a requested timestamp. Since timestamps for each key arrive in increasing order, binary search finds the matching entry.

from bisect import bisect_right


class TimeMap:
    def __init__(self):
        self.values = {}

    def set(self, key: str, value: str, timestamp: int) -> None:
        if key not in self.values:
            self.values[key] = ([], [])
        times, entries = self.values[key]
        times.append(timestamp)
        entries.append(value)

    def get(self, key: str, timestamp: int) -> str:
        if key not in self.values:
            return ''
        times, entries = self.values[key]
        index = bisect_right(times, timestamp) - 1
        return entries[index] if index >= 0 else ''

set takes O(1) amortized time; get takes O(log k), where k is the number of values for that key. Space complexity is O(n) for all stored entries.

What eBay's CodeSignal Test Format Actually Looks Like

The ebay coding assessment comes in two tracks, and the GCA format is the one most SWE applicants face. The ICA track is a project round for some roles. Both run on CodeSignal with proctoring on.

GCA: 4 Tasks in 70 Minutes

The General Coding Assessment is four coding tasks in 70 minutes, in any language. The framework suggests a 10/15/20/30 minute split across the four tasks, with the last one near LeetCode-Medium and hashmap-heavy. I planned around that split and it matched my test.

ICA: 4 Sequential Levels, Unlock to Proceed

The Industry Coding Assessment is a project codebase with four sequential levels. Each level must pass before the next unlocks. You build features on the same code as you go, which rewards clean structure over speed.

The 2-vs-4 Dispute Resolved

Some write-ups claim eBay sends two coding tasks plus SQL or data questions. The official framework, the GitHub tracker, and the 900/1200 score post all confirm four GCA tasks. I treat the two-plus-SQL claim as a role-specific outlier, not the standard SWE format.

How eBay's CodeSignal Scoring Works

eBay's CodeSignal score reflects how many tasks you solved and how correct each solution is. The chart below maps reported scores to outcomes and shows a passing mark is not a guaranteed next step.

The 200–600 Scale (Since 2023)

CodeSignal scores run from 200 to 600 since spring 2023, when the old 300 to 850 scale retired. A higher number means more tasks solved cleanly. The GitHub tracker confirms this is the current scale for both GCA and ICA comments.

GCA Instance May Report 900/1200

One GCA score post reports 900 out of 1200, which is four times 300. That conflicts with the 600-scale used in ICA comments. I surface both numbers because candidates see both, and neither source reconciles them.

Partial Credit and Retake Cooldown

Partial credit is more generous since 2023, so a brute-force Q4 still earns half points. The retake cooldown is two tests per rolling 30 days and three per rolling 6 months. I would rather submit a weak Q4 than leave it blank.

eBay CodeSignal Exam-Day Strategy

The exam-day plan is about pacing and picking the right setup, not last-minute learning. The confirmed reports point to a few moves that kept my test clean.

Pace Q1 and Q2 in 10 Minutes

The first two tasks are easy and should finish in about ten minutes total. I treated Q1 and Q2 as warm-up and banked that time for Q3 and Q4. That buffer is what saved me on the final task.

Pick an Editor You Trust

The Java VS Code editor on CodeSignal lacks basic helpers like getters and setters, which hurts productivity under the clock. I chose Python, which I know best, and avoided the editor friction entirely. Pick the language whose tooling you trust under pressure.

Retakes Are Offered

A second ICA link can arrive so a candidate retakes to improve the score. eBay does send repeat links in some drives, so a weak first pass is not always the end. I would still aim to do well on the first attempt.

Why Candidates Fail the eBay CodeSignal Assessment

Most failures are not about a single hard question. They come from detection, timing, and score floors that sit below the invite line. The patterns below repeat across reported outcomes.

AI Tools Get Caught After Submission

AI-TOOL-DETECTION CASE (private evidence, no URL): A candidate ran an Invisible App during the eBay CodeSignal assessment, submitted with no interruption or flag at the time, and later received notice that the result had been invalidated (score voided, application affected).

This was a private account, not a public post. The anti-cheat review runs after submission and catches help that looked invisible on screen.

At least one candidate was flagged for using an Invisible App. The tool renders the AI's answer on the same screen the proctoring system is monitoring, hidden by a basic OS-layer trick.

The structural difference with dual-device AI interview assistant is that the answer appears on a phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

Clearing the OA Doesn't Mean an Interview

Clearing the OA still leaves you waiting. Two ICA clearances brought no hiring-drive invite at all (the November 7–10 drive and a shared-details case are detailed in the timing-risk section below). A 600 out of 600 GCA sat silent for more than 20 days.

A Mid Score Still Screens Out

A mid score can screen you out before any human reads it. Scores of 350 and 400 out of 600 brought no call at all. A 530 out of 600 ML OA got no HR email before or after. eBay's batch-sent OA screens on score first, and a pass is necessary but not enough.

How to Prepare for the eBay CodeSignal in 7 Days

I planned my prep around the confirmed format instead of a broad LeetCode sweep. The seven days split into orient, drill, and simulate, with a buffer before the test. The timeline below shows the split.

Orient (Days 1–2)

I skip DP drilling because the GitHub OA tracker shows no DP problems in the confirmed GCA or ICA pool. I skip graph-theory drilling because the confirmed pool contains no graph problems.

I skip deep system-design prep for the GCA because the GCA is a DSA round, not a design round. I instead confirm the proctoring rules, the 70-minute format, and the four question families from the reports.

In the days before the OA, I also used the Prep Agent from an AI interview copilot (via WhatsApp or SMS): I sent it the confirmed question patterns for this company and got a personalized drill plan and strategy back. It slotted into the orient step as one practical tool among the others.

Drill (Days 3–5)

I drill broad GCA patterns in arrays, string processing, mutable state, and grids. I also practice class design and time-indexed lookups for the ICA track in case I get that format. Each drill runs against a timer so the pace feels real.

Simulate + Buffer (Days 6–7)

I run one full 70-minute GCA pass or one full ICA level-unlock pass on day six. Day seven is low-intensity review only, no new problems. I want the test to feel like a repeat, not a surprise.

What Happens After You Submit the OA

Submission is not the end of the loop. The wait and the next contact depend on score, drive window, and a recruiter's read. The ebay oa still gets a human review after the batch send.

Cleared ≠ Invited

A cleared OA does not guarantee an invite. An ICA clearance showed no drive invite in the dashboard. A 900 out of 1200 GCA scored but the careers page stayed empty. A 600 out of 600 GCA waited more than 20 days with no response.

Recruiter via LinkedIn and Email

Recruiters reach cleared candidates through LinkedIn DMs and email, not only the careers portal. Multiple cleared candidates reported a LinkedIn message from an eBay recruiter. The result link itself arrives by email, so watch that inbox.

Is the eBay OA Automatic?

The ebay oa is not pure automation. eBay sends it in batches after a light profile review, which makes it feel automatic, but a recruiter still reviews each result. My invite email said they had reviewed my profile and wanted to move forward. The link arrives by email, not by an instant bot.

Cleared ≠ Interview: eBay's Hiring-Drive Timing Risk

The biggest hidden risk is timing, not the test itself. A passing score can still miss the hiring-drive window and leave you with nothing. The data below shows both sides.

Two ICA Authors Cleared, Got No Drive

Two ICA authors cleared their assessments and got no hiring-drive invite. One cleared and heard nothing for the November 7 to 10 drive. The other cleared, shared details, and got no further mail. Clearing alone did not open the door.

High Scores Still Ghosted

High scores do not always convert. The same 600/600 GCA silent for 20+ days and 530/600 ML OA with no HR email already shown in the score-floor section above repeat here. The score was strong, but the next step never came.

Timing Gates the Next Step

A cleared candidate got a Bengaluru drive email for September 12 to 15, which shows the drive window matters. eBay sends the OA in batches, so both your score and the open drive window decide the outcome. I treat a pass as qualified, not as a guaranteed interview.

FAQ

Is the eBay OA automatic?

The eBay OA is not fully automatic. eBay sends it in batches after a light profile review, then a recruiter reviews each result. The full timing detail is in the "Is the eBay OA Automatic?" section above.

ebay oa reddit: where do candidates post their experiences?

Candidates post on r/csMajors, r/leetcode, and LeetCode Discuss most often. I read those threads before my own test. Teamblind also carries a few reports.

What is the ebay coding assessment?

It is a CodeSignal GCA with four tasks in 70 minutes, or an ICA project track. You pick any language you like. The GCA is the common SWE screen.

How long is the ebay online assessment?

The GCA runs 70 minutes for four coding tasks. The ICA track has four levels you must unlock in order. Plan for a single sitting either way.

How is the eBay CodeSignal scored?

Scores use a 200 to 600 scale, though some GCA runs report 900 out of 1200. Partial credit is generous on incomplete tasks. The scale is current since 2023.

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

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 sits on screen, and the hiding is basic.

Proctoring software keeps adding detection capabilities, so the risk exposure is not fixed.

In contrast, screen-share-safe AI interview tool 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.