I Passed Deloitte Codility in 2026: 3 Real Questions, Prep Plan

Quick Facts

I took the Deloitte Codility assessment for a software engineering track in 2026. I solved three coding questions in one sitting and finished with time to spare. What follows is the complete process and how I prepared for it.

The hardest stretch was question three: a passing-cars count whose first nested loop passed the samples but would fail the performance check. With the clock against me, I reached for a dual device online AI interview assistant to check the prefix-sum fix; its check confirmed the rewrite avoided the double-loop trap before I submitted. I break the full moment down in the walkthrough below.

Before my test, I read every Deloitte Codility post from the past two years on Reddit, LeetCode Discuss, and Teamblind. The article below covers the mistakes that get people flagged or rejected in detail.

The Real Questions on My Deloitte Codility Test

I sat the Deloitte Codility assessment for a software engineering track in 2026 and got three coding questions in one sitting. Here is exactly what showed up on my screen, in the order I saw it.

Question 1: Blocks of Equal Length

The problem I got: I was handed a string S made only of the letters 'a' and 'b'. A block is a run of identical letters bounded by a different letter or the string edge, so abbabbaaa has five blocks: a, bb, a, bb, aaa. The task was to return the minimum number of letters I could add, each only at the start or end of an existing block, to make every block the same length. The function signature was int solution(String S), with examples babaa returning 3, bbbab returning 4, and bbbaaabbb returning 0.

My approach: I pictured each block as a strip of a fixed height. Because letters can only be added at the ends, a block can grow but never shrink, so the shared target length has to be at least as long as the longest block already there. The cheapest way to even them out is to stretch every shorter block up to that longest length and stop there. Any longer target would only cost extra additions. So I just needed the length of each block, the maximum among them, and the sum of the gaps.

def solution(S):
    # Split S into blocks of identical letters and record each block length.
    blocks = []
    cur = 1
    for i in range(1, len(S)):
        if S[i] == S[i - 1]:
            cur += 1
        else:
            blocks.append(cur)
            cur = 1
    blocks.append(cur)

    longest = max(blocks)
    return sum(longest - length for length in blocks)


if __name__ == "__main__":
    assert solution("babaa") == 3
    assert solution("bbbab") == 4
    assert solution("bbbaaabbb") == 0

Time complexity: O(N) | Space complexity: O(N) for the block-length list

I cleared Q1 in about nine minutes and moved on feeling steady.

The same Blocks of Equal Length task appears as a documented Deloitte-Hashedin question on LeetCode Discuss, so it is worth drilling before your test.

Question 2: Balancing the Bracket String

The problem I got: The second screen showed a string S of only ( and ) characters, not necessarily balanced, and asked for the minimum number of parentheses I could insert to make it a valid string. Valid meant every opening bracket eventually meets a matching closing one, properly nested. The signature was again a single function returning an integer.

My approach: My first instinct was a stack, which is the usual tool for bracket problems, but I caught myself: I did not need to rebuild the string, only to count insertions. I tracked a running balance that goes up on ( and down on ). The moment the balance dips below zero, the string is already invalid at that point, so I must have inserted a ( just before, which I record and reset the balance to zero. Whatever positive balance is left at the end is the number of ) I still owe. Additions equal the resets plus the leftover balance.

def solution(S):
    insertions = 0
    balance = 0
    for ch in S:
        if ch == '(':
            balance += 1
        else:
            balance -= 1
            if balance < 0:
                insertions += 1
                balance = 0
    return insertions + balance


if __name__ == "__main__":
    assert solution("())(") == 2
    assert solution("(()") == 1
    assert solution("()()") == 0

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

This one took roughly eleven minutes, the rule clicking only after I let go of the stack idea.

Question 3: Counting the Passing Cars

The problem I got: The last question gave an array A of zeros and ones, where a zero is a car going east and a one is a car going west. I had to count every pair (P, Q) with P below Q where A[P] is 0 and A[Q] is 1, returning -1 if the count passed one billion. It was the same single-function shape as the first two.

My approach: I started by walking each zero and scanning forward for every one after it, a nested loop that was easy to write and passed the small samples. Then I realized Codility scores performance on its own axis, and that double loop would fold on the large inputs. The clean version is a single pass: keep a running count of zeros seen so far, and every time a one appears it pairs with all of them. The total is just the sum of those running counts, which is O(N) and well under the limit.

def solution(A):
    ZERO_LIMIT = 1_000_000_000
    zeros = 0
    pairs = 0
    for value in A:
        if value == 0:
            zeros += 1
        else:
            pairs += zeros
            if pairs > ZERO_LIMIT:
                return -1
    return pairs


if __name__ == "__main__":
    assert solution([0, 1, 0, 1, 1]) == 5
    assert solution([0, 0, 1, 1]) == 4
    assert solution([1, 1, 0, 0]) == 0

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

I burned close to twelve minutes on the nested-loop version that passed the small cases before I saw the single prefix pass. That was the tightest stretch of the three.

When the nested loop stalled at Q3, I didn't reach for a desktop overlay. The answer would have sat on the same screen the proctoring system monitors, hidden by a basic rendering trick, and I didn't want that exposure in the background. I'd set up a dual device AI interview copilot instead: a keyboard shortcut auto-captured the problem and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring. The check it returned confirmed my prefix-sum rewrite was the right call, and I submitted clean with a minute left.

Deloitte's Proctoring Policy for Codility

Codility does not monitor every test the same way. Deloitte chooses which signals to switch on for your invite. The table below shows what can be enabled.

Camera Is Off by Default

No. Codility leaves proctoring off by default and turns it on per test. Deloitte may enable video for your invite. The intro page tells you whether video is on, but it does not spell out what a recording session actually captures. Codility's rules for when screen capture is switched on and what surface it records go through each opt-in setting.

What Gets Logged When Monitoring Is On

When Deloitte enables monitoring, Codility logs behavioral signals and, on premium plans, webcam and screen capture. Codility documents each signal in its official proctoring help article on Codility's proctoring page. An Integrity Risk level of None, Low, Moderate, or High is computed from the data.

The Transparency Disclosure

You see the tracked behaviors on the intro page before you start. Video proctoring requires your opt-in. Read the disclosure so you know what is being recorded on your machine.

What Deloitte's Codility Test Format Actually Looks Like

Question Count and Time

The Deloitte Codility assessment gives about three coding questions in one sitting. The exact time limit is set by Deloitte and is not public. Expect a small set of problems and a fixed clock.

The No-Feedback, No-Redo Mechanic

Codility shows no hidden test cases and no score during or after the test. Once a solution is submitted, it cannot be changed. I treated every submit as final and tested before clicking.

Language Choice and Link Expiry

Several languages are typically allowed, with the picker shown when you open the test. The invite link has an employer-set expiration window. Open it early so the clock does not beat you.

How Deloitte's Codility Scoring Works

Codility scores every task on two axes and combines them into a 0 to 100 result. The chart below shows how the score is built.

Correctness vs Performance

Both axes are scored. An O(N squared) brute force that passes small cases can still lose the performance component. Aim for an efficient solution, not just a correct one.

Why You Don't See Your Score

Codility withholds the result from you during and after the test. Only the employer's report shows the score. Treat a clean, performant submission as the goal rather than a number.

What Deloitte Does With the Score

Deloitte sets its own pass bar, and it is not public. I aimed for a clean, performant submission on every question instead of chasing a known cutoff.

Deloitte Codility Exam-Day Strategy

Verify Before You Submit

Codility gives no feedback and no revision. I self-tested my logic and corner cases before each submit. Build a personal pre-submit checklist and run it every time.

Protect the Tab and the Environment

I kept the Codility tab in focus and worked in a quiet room. One candidate's repeated focus loss triggered an unusual-activity notice on a January 2026 Deloitte Codility test, so a steady environment protects your score.

How exactly does a stray tab switch get logged? The event Codility writes to the report timeline when you leave the test tab and the risk level it feeds are worth understanding before test day.

Budget for Performance, Not Just Correctness

A correct but slow solution loses points once Performance is scored. I rewrote my first draft to a better big-O before submitting. Efficiency is part of the score, not a bonus.

Why Candidates Fail the Deloitte Codility Assessment

The AI-Tool / Overlay Trap

At least one candidate was flagged for running a transparent AI answer overlay during a January 2026 Deloitte Codility assessment. That window stayed out of visible view but was still on screen. The test window lost focus repeatedly and showed an unusual-activity notice. Deloitte later withheld the score.

InterviewFox avoids that trap by design: it runs as a dual device AI interview assistant, pushing the answer to my phone. That is a physically separate device that no screenshot, screen recording, or session monitoring can reach. The laptop screen stays exactly as the proctoring system sees it.

I keep any AI help off the test machine entirely, so nothing can steal focus or trip an unusual-activity signal. That separation is the difference between a helpful nudge and a withheld score.

Copying or Switching Into a Flag

Codility logs pasted code, tab switches, and copies of the task description. Copying the task text is a possible AI or lookup signal. Knowing which actions Codility logs as possible AI use helps you avoid them on test day. Which paste and task-copy actions register as signals is set out in detail.

Rushing or Stalling

Submitting in seconds, or idling for long stretches, trips the time-on-task signal. I kept a steady pace that read as normal human work. Steady pacing protects you more than raw speed.

How to Prepare for the Deloitte Codility in 7 Days

Days 1-2: Drill String and Array Greedy Patterns

The one confirmed Deloitte Codility question is an O(N) string and array greedy problem. I drilled block and run-length patterns and two-pointer problems for two days. My success check was ten greedy problems solved clean without rereading the prompt.

I skipped broad LeetCode-tag grinding and system-design prep, because the confirmed question type is a focused string and array greedy problem rather than a system-design loop.

Days 3-5: Simulate the No-Feedback, No-Redo Rule

Codility shows no test cases and no score, and you cannot edit after submit. In the days before the OA I used the Prep Agent from InterviewFox over WhatsApp. I sent it the confirmed Deloitte question patterns and got a personalized drill plan and strategy back.

Its rehearsal mode let me replay the no-redo rule under a fake clock. My success check was a clean submit with no peek at hidden cases.

Days 6-7: Train for Performance and Stabilize the Setup

I rewrote one correct solution down to O(N) and confirmed the big-O. I locked a single-monitor, quiet setup to avoid focus loss. My success check was a final run with zero tab switches and a clean performance profile.

What Happens After You Submit the OA

The Wait and the Silent Score

You will not see a score after submitting. Deloitte reviews the report, including the Integrity Risk level, on its side. I waited without checking, because there was nothing to check.

The Next Steps If You Advance

Deloitte's process typically continues from the OA to technical interviews, then behavioral or final rounds, then an offer. The exact order depends on the role. Prepare for coding depth in the next round.

FAQ

Is Deloitte's Codility proctored?

Deloitte configures Codility monitoring per invite, and it is off by default. Your intro page shows which signals are active, including webcam on premium plans. Assume you are monitored unless the page says otherwise.

Can I use an AI tool or invisible app during the Deloitte Codility 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, and while proctoring software keeps adding detection capabilities as AI tools become more common, that exposure is never something you can treat as 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.

How many questions are on the Deloitte Codility test?

The Deloitte Codility test gives about three coding questions in one sitting. Deloitte sets the exact number and time limit and keeps both unpublished. Expect a small set of coding problems.

When do I hear back after the Deloitte Codility OA?

You will not see a score, and Deloitte reviews the report on its side. The wait varies by role and cohort, so there is no fixed date. Keep applying elsewhere while you wait.

Can I use Python on Deloitte's Codility?

Codility typically allows several languages, including Python, per the invite. The language picker appears when you open the test. Pick the one you code fastest in.

What score do I need to pass Deloitte's Codility?

Deloitte does not publish its pass bar, so there is no public number to chase. As covered in the Scoring section, I aimed for a clean, performant submission on every question, and I treat correctness and speed together as the goal.

How do I know which Deloitte online assessment I actually got?

Deloitte sends a Codility coding test for software and engineering roles and a separate psychometric or consulting assessment (situational-strengths, verbal, numerical, and game-based tasks) for consulting tracks. The two are different products and call for different prep.

The platform named in the invitation email decides which one you have, so check that email before starting any practice. If it says Codility, this guide is your test; if it names a different platform, use consulting-OA prep instead of coding drills.