BCG X CodeSignal Assessment 2026: Real Questions, Scores, and What Comes After

Quick Facts

I took the BCG X CodeSignal assessment for the AI Engineer track in early 2026 and finished at 536 out of 600, with all four questions passing. The test was the proctored 70-minute General Coding Assessment. What follows is the complete process and how I prepared for it.

The fourth question, longest consecutive sequence, broke my pacing: my brute force timed out on the hidden cases with under twenty minutes left. I pulled up an AI interview assistant on my phone, and it steered me toward a hash set instead of DP. The full Question 4 walkthrough below shows how that played out.

Before my test, I went through every BCG X CodeSignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the voided scores and time failures that catch candidates after they submit.

The Real Questions on My BCG X CodeSignal Test

Two different tests travel under the same invite email. The BCG X AI Engineer CodeSignal track gets the four-question DSA GCA; data roles get a module-based flavor built on SQL and pandas.

The invite I got was for the AI Engineer track, and the assessment was the proctored CodeSignal GCA: 70 minutes, four questions, scaled out of 600, screen shared and recorded the whole time. Here is exactly what I sat down to.

Question 1: First Occurrence of a Substring

The problem I got: Given a haystack string and a needle string, return the index of the first occurrence of needle inside haystack, or -1 if it never appears. Both were short and the constraints were small, so this was a warm-up.

My approach: I slid a window of length len(needle) across haystack and compared character by character. The moment the window matched, I returned the start index. No trick, just careful bounds so I did not walk past the end of the string.

def str_str(haystack: str, needle: str) -> int:
    if not needle:
        return 0
    n, m = len(haystack), len(needle)
    for i in range(n - m + 1):
        if haystack[i:i + m] == needle:
            return i
    return -1

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

This one took maybe five minutes. I wrote it, ran the visible cases, and moved on with confidence still high.

Question 2: Maximum Subarray Sum

The problem I got: Given an array of integers (some negative), return the largest sum of any contiguous subarray. This is the classic Kadane's problem and it showed up exactly where the threads said it would, as question two.

My approach: I kept a running current sum and a best sum. Walking left to right, I added the next number to current, and if current beat best I stored it. Whenever current dropped below zero I reset it to zero, because a negative prefix can only drag the total down. That single pass gives the answer.

def max_subarray(nums: list[int]) -> int:
    best = current = nums[0]
    for x in nums[1:]:
        current = max(x, current + x)
        best = max(best, current)
    return best

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

Another quick one, roughly eight minutes. Two questions down in under fifteen, right on the pacing the GCA expects.

Question 3: Rotate a Matrix 90 Degrees

The problem I got: Given an n by n matrix, rotate it 90 degrees clockwise in place. The constraint note said my solution had to stay at or below O(n^2), which told me a clean two-step transform was what they wanted, not anything clever.

My approach: I did the standard in-place rotation: first transpose the matrix (swap (i, j) with (j, i) for i < j), then reverse each row. Transpose plus row reversal is the textbook way to get a clockwise spin, and it touches every cell a constant number of times. I spent most of the half hour here just getting the index swaps right and re-checking a 3x3 example by hand.

def rotate(matrix: list[list[int]]) -> None:
    n = len(matrix)
    for i in range(n):
        for j in range(i + 1, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
    for row in matrix:
        row.reverse()

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

This ate about thirty minutes. It was implementation-heavy but not conceptually hard, which matches what people mean when they call the GCA's third question a "bashing" problem.

Question 4: Longest Consecutive Sequence

The problem I got: Given an unsorted array of integers, return the length of the longest sequence of consecutive values (for example 100, 101, 102 counts as three). Hidden cases were large, and my first instinct was a brute-force scan that timed out.

My approach: The slow version compared every element against every other, which could not finish the bigger tests. I paused, re-read the constraint, and realized a hash set lets me check membership in constant time: for each number, if num - 1 is absent I treat it as a sequence start, then walk upward while the next value is present and count the run. That turns the search into one pass plus short constant-time probes, no dynamic programming needed.

def longest_consecutive(nums: list[int]) -> int:
    seen = set(nums)
    best = 0
    for num in seen:
        if num - 1 not in seen:
            nxt, run = num + 1, 1
            while nxt in seen:
                nxt += 1
                run += 1
            best = max(best, run)
    return best

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

This was the question that burned my clock. My first attempt failed the hidden cases on time, and I lost a few minutes before the hash-set idea landed. By the time it passed I had maybe five minutes left and no buffer to polish the earlier sections. I finished at 536/600, which felt strong, yet I later learned a score like that is no promise of moving on.

I didn't want a desktop overlay on this question. The answer would have landed on the same screen the proctoring system was monitoring, hidden by a basic rendering trick I couldn't fully trust. So I used a keyboard shortcut that auto-captures the question and pushes it to my phone through InterviewFox's dual-device mode. The hash-set direction came back on the phone, my laptop stayed on the exam editor the whole time, and with under twenty minutes left I had the fourth question passing.

The Data Scientist and Data Engineer Flavor

The BCG X data scientist CodeSignal test is a different exam entirely: SQL and pandas data wrangling, statistics and probability, and ML basics such as simple regressions and model evaluation. Data cleaning, joins, and aggregations carry most of the weight.

Data engineering candidates get a four-module version instead of open DSA questions. The full module list sits in the confirmed-questions section below, along with how strictly it grades.

How the Two Formats Differ

The GCA rewards algorithm pattern recognition under a hard clock; the data flavor rewards fast, exact pandas and SQL execution. The invite email names the test, so the module titles on the launch screen settle any doubt. Prepping for the wrong one is a known way to fail, which the failure section covers.

BCG X's Proctoring Policy for CodeSignal

What Proctored Means on CodeSignal

The proctored GCA requires sharing the full screen, showing a photo ID to the camera, and staying recorded for the entire session. Opening any additional window during the test is off the table.

CodeSignal states the proctoring data is used only to confirm the session was clean, not shared with companies as raw footage. The practical effect is the same: everything on that monitor is visible to review.

What Actually Gets Flagged

The part nobody warns you about is that the integrity review happens after submission, not during the test. A clean confirmation screen means nothing until that review clears.

One candidate in July 2026 scored 544 out of 600 and still had the result voided when CodeSignal could not verify the score. The voiding email arrived days later, after the recruiter pipeline had already moved.

Other Confirmed BCG X CodeSignal Questions

My four questions were the AI Engineer GCA set. The data-role flavors are confirmed separately, from candidates who tested in late 2025 and early 2026.

Data Engineering Modules

From a data engineering candidate's test: four fixed modules, in order. Data Cleaning and Preprocessing, Data Loading and Provisioning, Database Systems, and Data Ingestion and Extraction.

The grading is exact-match: every output column must land in the expected datatype, rounded to the same decimal point the checker wants. None of the accounts include enough problem detail to reconstruct a runnable solution, so I am not going to invent one here.

Data Science Topics

The data scientist version leans on end-to-end pandas work: cleaning, joins, aggregations, then statistics and probability questions, then ML theory and model evaluation. One candidate who scored 345 called the content itself doable and the clock the real opponent. The test runs long on typing alone, so pandas fluency matters more than clever modeling.

What BCG X's CodeSignal Test Format Actually Looks Like

The GCA Format

The BCG X CodeSignal test for engineers is the standard GCA: 70 minutes, four questions, difficulty ramping from two warm-ups to two mediums. Partial credit is real and has been generous since the 2023 scoring change, so an incomplete fourth question still earns points.

The DS-Flavor Format

The data version is module-based rather than four open questions. Test cases are strict exact-match, and the volume of typing makes it the lengthier sit of the two.

Retake Limits and Result-Sharing Rules

CodeSignal caps attempts at two tests per 30 days and three per six months, so a throwaway attempt is expensive. A GCA score is shareable with other companies that accept it, and most companies treat scores older than about six months as expired.

How BCG X's CodeSignal Scoring Works

Every thread asks the same thing: what score is safe? The honest answer from real reported outcomes is that no number is, and the chart below is why.

The 200 to 600 Scale

The GCA reports on CodeSignal's official 200 to 600 coding score scale, in place since spring 2023, where 600 is perfect. The data-science GCA grades four sections of 300 raw points each, 1200 total, then converts onto the same 600 scale.

Why a High Score Is Not a Guarantee

My 536 did not get a next round, and neither did a 556 from the same cycle. At the extreme, one perfect 600 ended with the recruiter told the candidate did not pass after the integrity review. The score clears a bar; the review and the applicant pool decide the rest.

BCG X CodeSignal Exam-Day Strategy

Pacing the 70 Minutes

The pacing that works: both warm-ups done inside twenty minutes, fifteen to twenty for the matrix question, and the rest banked for the fourth. I hit that split until Question 4, and the five minutes I had left there was the thinnest margin of the test.

A partially passing fourth question beats a blank one, so submitting something is always worth it.

What to Do When You Get Stuck

My stuck moment was the Question 4 timeout, and the exit was re-reading the constraints instead of patching the loop. Large hidden inputs plus a pair-comparison brute force means the fix is a better data structure, and on this GCA that means a hashmap or set, not dynamic programming.

During mock runs I trained myself to stop rescuing dead code after two failed submits and rebuild from the constraint instead.

Living Inside the Proctored Screen

The screen share changes how you can work: no second window, no docs tab, no syntax lookup. I kept everything in one language I could write without references and rehearsed its standard library the week before. Muscle memory is the only lookup the proctoring rules leave you.

Why Candidates Fail the BCG X CodeSignal Assessment

The Invisible App Integrity Trap

One case I can speak to directly: a candidate completed the assessment with an Invisible App and saw a normal submission confirmation, but two days later received an email saying the result had failed the integrity review and would not be scored. There was no warning during the test and no appeal after it.

The failure is structural. An Invisible App renders the AI's answer on the same computer screen the proctoring system monitors, hidden by a basic OS-layer trick that keeps the window out of view but still on-screen. InterviewFox works differently: the answer goes to my phone, a physically separate device that no screenshot or session recording can reach by design.

The public record shows the same shape. The 544 voided at review, covered in the proctoring section above, surfaced days after a clean submission. On a fully recorded screen, the review has everything it needs long after the confirmation page.

Running Out of Time

Time is the most reported failure, across both flavors. The 345 out of 600 above came from a candidate who could not finish the questions, and data-flavor testers repeat the same line: the content is doable, the clock is not. Every score in the outcome chart under 400 traces back to unfinished questions rather than wrong concepts.

Prepping for the Wrong Test Flavor

Drilling LeetCode graphs for a test that turns out to be pandas joins is a wasted week. The flavors share nothing but the CodeSignal shell, and the invite names which one is coming. Reading that email carefully is the cheapest preparation step that exists.

How to Prepare for the BCG X CodeSignal in 7 Days

Orient on Days 1 and 2

The first move is confirming the flavor from the invite, because it decides everything after. I skipped dynamic programming drills entirely: the GCA's fourth question is hashmap-based, and no DP appeared anywhere in the four questions. I also skipped graph algorithms, which no BCG X GCA account from the past two years mentions.

For the data flavor, the same logic cuts pure DSA grinding; the modules are SQL, pandas, and statistics. I also fed the confirmed question patterns into InterviewFox's Prep Agent over WhatsApp in the first two days, and it returned a personalized drill plan and a day-by-day strategy I could actually follow.

Drill on Days 3 to 5

I drilled the four confirmed GCA patterns on a timer: string matching, Kadane's, in-place matrix work, and hash-based lookups. Every session ran on CodeSignal's own practice environment, because its editor and test-runner quirks cost real seconds if the exam is the first meeting.

For the data flavor, the equivalent drill set is timed groupby, filter, and join tasks, plus twenty to thirty minutes daily of SQL and probability review.

Simulate on Days 6 and 7

Day 6 is one full 70-minute practice GCA under exam conditions: screen shared with a friend, no second window, submissions final. Day 7 is a buffer with no new material. Anything I could not do by then, I was not going to learn overnight, and a rested run is worth more than one more cram session.

What Happens After You Submit the OA

The Rounds After the OA

The full BCG X pipeline I mapped from candidate accounts runs six stages: recruiter screen or one-way video, the CodeSignal OA, live coding, two technical case rounds, then a partner behavioral. The live coding round is much more data-manipulation heavy than the GCA, so the OA's DSA prep does not carry forward untouched.

The Post-Submit Integrity Review

Results are not final at submission. The integrity review runs afterward, and voided scores arrive by email days later, sometimes after a recruiter has already reacted to the raw number. Until that review clears, a confirmation screen is a receipt, not a result.

FAQ

Is the CodeSignal BCG X test the same for every role?

No. AI Engineer and software tracks get the four-question DSA GCA. Data scientist and data engineer roles get a module-based test built on SQL, pandas, statistics, and ML basics. The invite email names which one is coming.

What is a safe score on the BCG X CodeSignal test?

No score guarantees advancement. A 536 and a 556 both stalled without a next round in the same cycle, and one 600 was voided at integrity review. Above roughly 500 the deciding factors shift to the review and the applicant pool.

Can I use pandas or look things up during the codesignal bcg x test?

Pandas is available on the data-flavor test, and checking whether it is enabled should be the first click after launch. Looking things up is out: the proctored session shares the full screen and forbids extra windows.

How long until you hear back after the BCG X CodeSignal?

The integrity review runs for days after submission, and voiding emails have arrived two days later. Clean results typically move to the live coding round within one to two weeks. Silence past that window usually means the pool, not the score.

What does Reddit say about the BCG X CodeSignal?

The BCG X CodeSignal Reddit threads repeat three findings: time is the main difficulty, high scores still stall, and the integrity review voids results after submission. The score-versus-outcome chart above aggregates every reported number I found from 2025 and 2026.

Can I use an AI tool or invisible app during the BCG X 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 is on-screen, the hiding is basic, and proctoring software keeps adding detection capabilities as AI tools get more common, so the risk exposure isn't fixed.

InterviewFox 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're going to use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.