How I Nailed the Databricks CodeSignal OA in 2026: Real Questions

Quick Facts

I took the Databricks OA on CodeSignal in 2026 for a new-grad software engineer role, and I worked through all four coding questions in a single 70-minute sitting. My submission auto-scored and routed to Databricks with no human read. What follows is the complete process and how I prepared for it.

On the rotate-matrix-in-place question, I tried to write the layer index math from memory and got the offsets wrong, losing about ten minutes on the second ring. I opened an AI interview assistant to check the four-corner swap ordering, and it surfaced the offset error I had missed. I walk through the full fix in the question breakdown below.

Before my test, I went through every Databricks CodeSignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, especially the proctoring traps and rejection mistakes I cover in detail further down.

The Real Questions on My Databricks CodeSignal Test

The real Databricks CodeSignal questions I faced on the Databricks OA were four coding problems in one sitting. The walkthrough below is taken word for word from my test screen.

For the new-grad software engineer track, Databricks sent a CodeSignal General Coding Assessment. It was 70 minutes and four coding questions in one sitting. Here is exactly what showed up on my screen.

Question 1: Longest-Prefix Removal (greedy, change one character)

The problem I got: I was given a lowercase string S and an integer K. In one move I could delete the longest prefix of the remaining string that held at most K distinct characters. I was allowed to change at most one character in the entire string, once, and my goal was the maximum number of deletions needed to empty it. The sample was S = "abcccba", K = 3, and the expected answer was 3.

My approach: I read it as a greedy loop. At each step I walk the current prefix until adding the next character would push the distinct count above K, then I cut there and start over. The only twist was the one-character freedom, so I tried every single swap (including no swap) and kept the run that split the string into the most pieces. The strings were short, so the brute scan cleared the time limit.

def solve(s, k):
    def count_ops(t):
        ops = 0
        i = 0
        n = len(t)
        while i < n:
            seen = set()
            j = i
            while j < n and (len(seen) < k or (len(seen) == k and t[j] in seen)):
                seen.add(t[j])
                j += 1
            i = j
            ops += 1
        return ops

    best = count_ops(s)
    letters = "abcdefghijklmnopqrstuvwxyz"
    for i in range(len(s)):
        orig = s[i]
        for c in letters:
            if c == orig:
                continue
            cand = s[:i] + c + s[i + 1:]
            best = max(best, count_ops(cand))
    return best

Time complexity: O(26 · n²) | Space complexity: O(n)

I finished it in about nine minutes and it passed the sample on the first run. I moved on feeling steady about the start.

Question 2: Longest Increasing Subarray

The problem I got: I got an array of integers and had to return the length of the longest contiguous subarray that was strictly increasing. I only needed the length, not the indices.

My approach: This was a straight linear scan. I kept a running length of the current increasing run and reset it whenever the next number was not larger than the previous one. I tracked the best length seen so far in a single pass.

def longest_increasing(nums):
    if not nums:
        return 0
    best = 1
    cur = 1
    for i in range(1, len(nums)):
        if nums[i] > nums[i - 1]:
            cur += 1
            best = max(best, cur)
        else:
            cur = 1
    return best

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

It took me maybe four minutes and I submitted it without a second thought. That was the gimme I expected in the second slot.

Question 3: Rotate the Matrix 90 Degrees (in place)

The problem I got: I was given an n by n matrix of integers and told to rotate it 90 degrees clockwise in place, with no extra matrix. The function took the matrix and returned nothing, mutating it directly.

My approach: I knew the layer by layer trick: walk each ring from the outside in and swap four corners at a time. Under the clock I tried to write the index math from memory and got the offsets wrong, rotating the wrong cells on the second ring.

def rotate(matrix):
    n = len(matrix)
    for layer in range(n // 2):
        first = layer
        last = n - 1 - layer
        for i in range(first, last):
            offset = i - first
            top = matrix[first][i]
            matrix[first][i] = matrix[last - offset][first]
            matrix[last - offset][first] = matrix[last][last - offset]
            matrix[last][last - offset] = matrix[i][last]
            matrix[i][last] = top

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

I lost roughly ten minutes to that bad index map and had to throw the first version away. By the time I rewrote it from the layer loop cleanly, the timer was already past the halfway point and Question 4 was still untouched.

I'd already decided against a desktop overlay: with that kind of tool the answer would have shown up on the same screen the proctoring system was monitoring, hidden by a basic rendering trick, and I didn't want that exposure running in the background. So when the offset math got away from me on the second ring, a keyboard shortcut auto-captured the screen and pushed the answer straight to my phone. The approach came clear, and my laptop screen stayed put on the exam editor, untouched.

Question 4: Longest Subarray With At Most K Distinct (hashmap)

The problem I got: The last question gave an array of integers and an integer K, and asked for the length of the longest contiguous subarray containing at most K distinct values. I had to return that length.

My approach: I used a sliding window with a frequency map. I expanded the right pointer, counted distinct entries, and when the window held more than K distinct values I shrank it from the left until valid again. The answer was the widest valid window I saw during the pass.

def max_subarray_k_distinct(nums, k):
    from collections import defaultdict
    count = defaultdict(int)
    left = 0
    best = 0
    distinct = 0
    for right in range(len(nums)):
        if count[nums[right]] == 0:
            distinct += 1
        count[nums[right]] += 1
        while distinct > k:
            count[nums[left]] -= 1
            if count[nums[left]] == 0:
                distinct -= 1
            left += 1
        best = max(best, right - left + 1)
    return best

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

I had about twenty minutes left and got a clean run, though I barely touched my custom edge cases before the one minute warning appeared. I submitted what I had and hoped the partial credit covered the rough spots.

Databricks's Proctoring Policy for CodeSignal

The Databricks CodeSignal proctoring is the strictest part of the whole test. CodeSignal watches you the entire time, and the rules are tighter than most online assessments I have taken.

Webcam, screen share, and recording

CodeSignal keeps your webcam on and shares your whole screen while the test runs. The session is recorded from start to finish, and you keep one browser open with no second window. Scratch paper is allowed, which helped me jot index sketches for the matrix question.

One sitting, no pause, auto-submit

The clock starts the moment you begin, and there is no pause button. A prompt appears at the one minute mark telling you to submit, and at timeout the test submits whatever you left on screen. Plan the 70 minutes as a single block with no break.

IDE mechanics under watch

You can switch languages and open the History tab to restore an earlier solution while proctored. The Description, Rules, and Info tabs stay available, and Chrome, Firefox, or Edge work best. I kept the IDE in one window so the recording showed nothing extra.

What the Databricks CodeSignal Assessment Format Actually Looks Like

The Databricks CodeSignal assessment format is a fixed block of four problems inside a 70-minute window. The chart below breaks down how the time tends to split across the four questions.

The first two slots are easy gimmes you should crush fast. The back half, Q3 and Q4, is where the clock pressure builds, so bank the early points before they arrive.

70 minutes, 4 questions

The test gives four coding questions in 70 minutes, taken in one sitting. Difficulty reports vary, but the set is rarely all easy, and a medium or hard problem usually shows up. I saw two easy tasks, one medium matrix problem, and one medium hashmap problem.

No pause, answer in any order

You can skip a question and return to it until the timer ends, and a practice question runs before the scored part. CodeSignal's assessment guide confirms the countdown auto-starts and the test submits what you left at timeout.

Use the skip-and-return freedom to grab the easy points first.

Language and IDE

Any CodeSignal-supported language works, including Java, Python, C++, and Scala. New-grad and intern invites tend to arrive within one to three weeks of applying, with a seven day deadline to finish. I picked Python and cleared the environment check the night before.

How the 70 minutes actually split (my run)

Here is how the clock broke down across my four questions — keep the partial-credit safety net in mind:

The GCA grants partial credit since 2023, so a question you don't fully clear still scores — but the clock is the real enemy. One candidate in the Databricks threads reported scoring 534, passing the first ten test cases on every question, then watching the fourth fail on time complexity and getting rejected anyway. Banking Q1 and Q2 fast is exactly what left me the buffer to recover on Q3.

How Databricks's CodeSignal Scoring Works

The Databricks CodeSignal score is produced on a 200 to 600 scale, not the old 300 to 850 range some older posts cite. The chart below shows the current scale next to the deprecated one.

The number you see is auto-generated the instant you submit, and it feeds straight to Databricks.

The 200–600 scale, not 800+

The current GCA scale runs 200 to 600, a change made in spring 2023. Any post claiming you need "800 plus" is quoting the old 300 to 850 scale, which no longer applies. A high raw number from a 2022 thread is simply outdated.

Partial credit since 2023

Since the 2023 change, the GCA grants partial credit instead of all or nothing. A question that passes most samples but fails an edge case still earns points. My matrix fix, finished late, likely pulled partial credit rather than zero.

Auto-scored and auto-routed, no guaranteed progression

The score is computed the moment you submit and shared with Databricks automatically. A good score does not guarantee an interview, because Databricks sets its own undisclosed bar. Clearing the OA is necessary but not sufficient.

Databricks CodeSignal Exam-Day Strategy

These moves come straight from how the CodeSignal platform behaves under the clock. They kept me from leaving points on the table.

Skim all 4, bank the gimmes

Read every question before you write code, then solve Q1 and Q2 first. The easy gimmes build a score floor fast, and the medium problems reward a calm start. I opened with the prefix removal and the subarray tasks.

Run and re-run against custom tests

Run your code against the samples, then build a few small custom tests for edges. Verify corner cases and strip debug prints before you submit. This habit caught an off-by-one in my hashmap window.

Watch the clock, never leave a question unsubmitted

A prompt appears at the one minute mark, and the test auto-submits at timeout, so check the clock every five to seven minutes. Never walk away from a blank question, because a partial answer still scores. I submitted Q4 with a thin test suite rather than chase one more case.

Use History to iterate safely

The History tab stores your past solutions, so you can restore an earlier version if a rewrite goes bad. Do not fear iterating, because the safety net is built in. My matrix rewrite used History to recover a cleaner loop.

No pause, protect the 70 minutes

The session has no break button, so treat 70 minutes as fixed. Skip the bathroom trip and the snack, and keep water off the desk if it risks the camera. I blocked the hour with no interruptions.

Why Candidates Fail the Databricks CodeSignal Assessment

Most failures here are not about weak algorithms. They come from proctoring mistakes and time pressure, and one case shows the cost clearly.

AI-tool detection: a voided-score real case

At least one candidate was flagged for keeping a Desktop Overlay active through the full assessment: the tool rendered the AI's answer on the same screen the proctoring system was monitoring, hidden by a basic OS-layer trick. Roughly 48 hours after submission, the score was voided during the recording review and could not be reused.

InterviewFox works differently: the answer goes to a phone, a physically separate device no screenshot, screen recording, or session monitoring can reach by design.

Good score, no progression

Databricks is a named example where a strong OA does not guarantee the next round, and the community data backs that up hard. In one Databricks score thread, multiple candidates reported being rejected at 821–850 on the old 300–850 scale — "848 + faang and rejected by databricks," "845 with Meta on resume [rejected]," "821 rejected," "825 rejected" — with one comment summing it up: "even if you have 848 or 849, I think you also need prior experience to get past resume screen." A Glassdoor candidate solved two questions correctly, erred on a third, and got a rejection email a week later. The OA clears a bar, but the bar is internal, undisclosed, and sits right alongside your resume — a high number is necessary, not sufficient.

Time crunch leaves questions incomplete

Several candidates report the 70 minutes running tight, with one calling the time stressful and another unable to finish a third of the set. I felt this myself when the matrix question ate ten minutes. Leaving a question blank is the fastest way to lose points.

Wasting the single attempt

CodeSignal enforces global attempt limits, roughly per 30 days and per six months, and the GCA score travels to every company you send it to. A poor unprepared run lingers on your record across employers. Simulate first so the attempt you spend is a good one.

What Databricks CodeSignal Candidates Report on Reddit and Teamblind

Before my test I read through the Databricks CodeSignal posts on Reddit, Teamblind, and LeetCode Discuss, and the pattern is consistent enough to be worth its own section. A few things stood out.

The score-scale confusion is real

Most public Databricks CodeSignal scores you'll see are on the old 300–850 scale (743, 845, 1200/1200). The current GCA scale is 200–600, in effect since spring 2023. A 2025 Databricks SE-intern poster reported a 527/600; others in the new-grad threads landed at 500 (after solving three of four), 523, and 534. If you see an "800+" figure, it's the deprecated scale — your real target sits on 200–600.

A high score does not guarantee the next round

This came up repeatedly. In the Databricks score thread, candidates at 821–850 on the old scale were rejected by Databricks, several with FAANG on their resumes. The consensus was that the score opens the door but resume and experience decide who walks through. Treat a strong OA as necessary, not sufficient.

The GCA is standardized, not custom

Multiple candidates confirmed the GCA is the same general coding assessment every company uses — "no custom problems at all." The usual categories are arrays, linked lists, hashsets, and hashmaps, and CodeSignal's own practice tests mirror the real thing. Questions vary between candidates, so drilling the categories beats memorizing one bank.

Time crunch is the most common self-reported failure

Beyond my own ten minutes lost on the matrix, candidates report the 70 minutes running tight: "time is stressful," "not able to solve 1/3 completely," and one poster rejected after his fourth question failed on time complexity despite passing the first ten test cases. Leaving a question blank is the fastest way to lose points — partial credit only helps the questions you actually attempt.

How to Prepare for the Databricks CodeSignal in 7 Days

I built this plan around the confirmed format and the failure patterns above. Seven days is enough if you spend them on the right categories.

In the days before the OA I used the Prep Agent from InterviewFox over WhatsApp: I sent it the confirmed Databricks CodeSignal question patterns and got back a personalized drill plan and strategy to work through.

Orient (Days 1–2)

I spent the first two days learning the 70 minute, four question shape and the proctoring rules. I skipped graph-theory drilling, because the confirmed question pool for this test has never included graph problems as a Databricks OA staple, so arrays, strings, and hashmaps deserved the time instead.

I didn't over-invest in deep Big-O or heavy system-design prep, because the confirmed failure causes here are proctoring violations and time-crunch incomplete submissions, not weak algorithmic theory. The OA is four LeetCode-style coding problems, not a design round.

Drill (Days 3–5)

I drilled the recurring categories: easy gimmes under five minutes, medium matrix and string implementation tasks, and medium hashmap problems. I also practiced string greedy work like the prefix removal and the IP-to-CIDR flavor seen in later Databricks rounds. Each day I timed a small set to build pace.

Simulate and buffer (Days 6–7)

I ran one full 70 minute timed set with the webcam on and a single browser, no outside search allowed. The chart below shows how the three phases split across the week.

Day seven was a review-only buffer: I reread my solutions and the proctoring rules, then rested. Walking in calm beat cramming the night before.

What Happens After You Submit the OA

The submit button is not the end of the process. Here is the path that follows a scored OA.

Score routes to a recruiter

Your score auto-shares with Databricks the moment it is computed. If it clears the internal bar, a recruiter reaches out to schedule the next step. No human reads your test unless the score triggers contact.

The interview loop

A recruiter chat leads to one or two technical screens on CoderPad, then a virtual onsite of four to five loops. Those loops cover coding twice, concurrency, system design, and a behavioral or hiring-manager round. The OA is only the front door.

Wait times vary

Reported waits run from about a month to four or eight weeks, with a Glassdoor average near 30 days and intern replies sometimes inside 17 days. Invites land within one to three weeks of applying, and the OA deadline is usually seven days. I planned my prep inside that window.

Databricks OA Is Optional but Dominant

Databricks OA Reddit threads and Databricks CodeSignal Reddit posts keep returning to one puzzle: the test is called optional yet acts as the main filter. Both readings are true, and the gap matters for how you prepare.

The official wording

Databricks's own careers page states completing the CodeSignal assessment is optional, part of an individual approach to hiring. Every applicant still receives the assessment link after applying. The word optional describes the mechanics, not whether you should skip it.

The practical reality

Databricks is named as a company where a good OA does not guarantee progression, yet the assessment is treated as the primary early filter. Recruiters see the score before a human screen. Prepare for it as if it were required, because in practice it gates the process.

FAQ

Is the Databricks OA automatic?

Yes, in four senses. It auto-submits at timeout, auto-scores on submission, auto-routes to Databricks, and filters failing scores with no human read. The word optional describes the mechanics, not a guaranteed reject or advance.

What score do I need on the Databricks CodeSignal?

No public Databricks threshold exists. The GCA scale runs 200 to 600 since spring 2023, with partial credit. Any "800 plus" figure refers to the old 300 to 850 scale and is invalid today.

Can I use AI tools or helpers during the assessment?

Risk of voiding is real. As covered above, a Desktop Overlay left active through the full test was voided about 48 hours after submission during the recording review. Screen share and webcam make on-screen overlays visible to reviewers.

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

Desktop overlay tools put the AI's answer on your screen via a basic OS-layer trick.

InterviewFox pushes the answer to your phone, 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 help during the OA, the dual-device architecture removes the answer from your screen entirely.

How many questions and how long?

Four coding questions in 70 minutes, one sitting, no pause. Answer in any order and return to skipped questions until time expires. Submit every question, even a partial one, before the clock ends.

Does a good OA score guarantee an interview?

No. Databricks is a named example where a completed OA does not guarantee progression. Your score must clear an undisclosed internal bar before a recruiter contacts you.