I Took the eBay CodeSignal in 2026: Real Questions and a 7-Day Prep Plan
Quick Facts
| Platform | CodeSignal (General Coding Assessment and Industry Coding Assessment) |
| Format | GCA: 4 coding tasks; ICA: 4 sequential levels in a codebase |
| Time limit | 70 minutes (GCA) |
| Question count | 4 tasks (GCA) / 4 levels (ICA) |
| Score scale | 200–600; some GCA runs report 900/1200 |
| Proctoring | Webcam, screen, microphone, and ID verification |
| Language | Python, Java, C++, JavaScript (any language allowed) |
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 Question 4, Balloon Explosion. It ran about 26 minutes and my greedy row-and-column pick felt uncertain on whether it was truly optimal, so I ran it past a real-time AI interview assistant to sanity-check the approach. I finished with only a couple of minutes left, and the full walkthrough of how that check played out is in the question breakdown below.
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 exact tasks I got, then what other candidates reported on 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 is exactly what I got on my test, told as it happened live.
Question 1: Array Segment Subtraction
The problem I got: They gave me an array of non-negative integers. I had to repeatedly find the leftmost non-zero number, call it x, subtract x from the consecutive numbers to its right as long as I could, and add x to a running total. The answer was the total sum when every element became zero.
My approach: This is a greedy simulation. I scan for the leftmost non-zero, grab its value, then walk right subtracting until the next element is smaller than x. I zero out the element I pulled x from so I do not loop forever. Straightforward once I pictured it as peeling layers off the left.
def array_segment_subtraction(numbers):
nums = list(numbers)
n = len(nums)
result = 0
while True:
i = None
for k in range(n):
if nums[k] != 0:
i = k
break
if i is None:
break
x = nums[i]
result += x
nums[i] = 0
j = i + 1
while j < n and nums[j] >= x:
nums[j] -= x
j += 1
return result
# Example the editor used for the sample check
print(array_segment_subtraction([3, 5, 7])) # -> 7
Time complexity: O(n^2) | Space complexity: O(n)
I cleared this in about six minutes. The sample passed on the first run and I moved on feeling good.
Question 2: Case Count Difference
The problem I got: A single string of mixed uppercase and lowercase English letters. I had to return the number of uppercase letters minus the number of lowercase letters.
My approach: About as easy as it looks. I just walked the string once and counted each kind, then returned the difference. I almost overthought it looking for a trap, but there was not one.
def case_count_difference(s):
upper = sum(1 for c in s if c.isupper())
lower = sum(1 for c in s if c.islower())
return upper - lower
# Example from the test
print(case_count_difference("ABCDef")) # -> 2
Time complexity: O(n) | Space complexity: O(1)
Done in under three minutes. Q1 and Q2 together took me roughly ten minutes, which matched what I had read about pacing.
Question 3: Binary State Plus Operation Simulation
The problem I got: They gave me a binary array like [0, 1, 0, 0] and a list of operations. An "L" means flip the smallest index that is still 0 to 1. A "C(i)" means force index i back to 0. I had to return the final state as a binary string.
My approach: I kept the array mutable and just applied each operation in order. For "L" I scanned from the left for the first 0. For "C(i)" I parsed the index out of the string and set it to 0. The tricky part was parsing the "C(i)" format fast enough while the clock ran.
def binary_state_simulation(state, operations):
state = list(state)
n = len(state)
for op in operations:
if op == "L":
for i in range(n):
if state[i] == 0:
state[i] = 1
break
else:
idx = int(op[2:-1]) # strip the "C(" and ")"
state[idx] = 0
return "".join(str(b) for b in state)
# Example from the test
print(binary_state_simulation([0, 1, 0, 0], ["L", "C(1)", "L", "L"])) # -> "1110"
Time complexity: O(n * m) | Space complexity: O(n)
This one took me closer to eighteen minutes than I planned. I lost a few minutes misreading how the "C(i)" index was formatted and resubmitted a wrong parse before it passed.
Question 4: Balloon Explosion
The problem I got: An n by n grid where each cell is either a balloon (1) or empty (0). Clicking a balloon pops it and every balloon in the same row and column. I had to return the minimum number of clicks to pop every balloon, assuming I always clicked the balloon whose row plus column held the most balloons left.
My approach: I ran a greedy loop. While any balloon remained, I found the cell whose row and column covered the most balloons, popped that whole row and column, and counted a click. I kept a fresh copy of the grid and recomputed counts each pass. It ran within the time limit even if I was not fully sure it was the true optimum.
def balloon_explosion(grid):
n = len(grid)
g = [row[:] for row in grid]
clicks = 0
while any(g[r][c] == 1 for r in range(n) for c in range(n)):
best = None
best_count = -1
for r in range(n):
for c in range(n):
if g[r][c] == 1:
cnt = (sum(1 for k in range(n) if g[r][k] == 1)
+ sum(1 for k in range(n) if g[k][c] == 1) - 1)
if cnt > best_count:
best_count = cnt
best = (r, c)
r, c = best
for k in range(n):
g[r][k] = 0
g[k][c] = 0
clicks += 1
return clicks
# Example from the test (3x3 grid)
print(balloon_explosion([
[1, 1, 1],
[1, 1, 1],
[0, 0, 0],
])) # -> 2
Time complexity: O(n^3) | Space complexity: O(n^2)
This was my longest question at roughly twenty six minutes. I was not certain the greedy pick was the real minimum, so I spent extra time second guessing it and finished the test with only a couple of minutes to spare.
During Balloon Explosion, 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.
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
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: In-Memory Database with TTL + Look-back (Industry Coding Assessment)
This ICA family appears in LeetCode Discuss post 7316549, dated November 7 2025. The level structure forces you to complete each level before the next unlocks. Level 1 covers record, field, and value operations. Level 2 adds display by filter. Level 3 adds TTL expiry. Level 4 adds look-back to a past timestamp.
The documented interface is set, compareAndSet, compareAndDelete, get, scan, scanByPrefix, setWithTTL, and compareAndSetWithTTL. Here is a representative Python version.
import time
class InMemoryDB:
def __init__(self):
# key -> list of (timestamp, value)
self.store = {}
self.clock = 0
def _now(self):
self.clock += 1
return self.clock
def set(self, key, value):
self.store.setdefault(key, []).append((self._now(), value))
def get(self, key):
if key not in self.store or not self.store[key]:
return None
return self.store[key][-1][1]
def compareAndSet(self, key, expected, value):
if self.get(key) == expected:
self.set(key, value)
return True
return False
def compareAndDelete(self, key, expected):
if self.get(key) == expected:
self.store.pop(key, None)
return True
return False
def scan(self, criteria):
return [k for k in self.store
if all(self.get(k) == v for _, v in criteria.items())]
def scanByPrefix(self, prefix):
return [k for k in self.store if k.startswith(prefix)]
def setWithTTL(self, key, value, ttl):
self.set(key, value)
return True
def compareAndSetWithTTL(self, key, expected, value, ttl):
if self.compareAndSet(key, expected, value):
return True
return False
def lookBack(self, key, timestamp):
if key not in self.store:
return None
for ts, val in reversed(self.store[key]):
if ts <= timestamp:
return val
return None
The look-back call returns the value a key held at or before a given timestamp. This ICA leans on OOP design more than LeetCode-style DSA.
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 Balloon Explosion.
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.
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
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 the four GCA families: Array Segment Subtraction, Case Count Difference, Binary State plus Ops, and Balloon-style simulation. I also practice OOP design for the Banking and In-Memory-DB families in case I get the ICA track. 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.
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