How I Aced the DRW Codility OA in 2026: Real Questions

I took the drw oa for a DRW new grad software engineer role in 2026 on Codility and worked through all three coding questions in about 150 minutes. What follows is the complete process, the real questions, the proctoring rules, and how I prepared for it.

Quick Facts

Question 3 looked simple, modify a dedup function to run in place, but I froze on whether the constraint even allowed overwriting the input, and the clock drained while I sat on it. For a few minutes I thought that one question might sink the whole test. During that freeze on the in-place constraint, a real time AI interview helper on my phone walked me through the edge case without leaving a trace on the screen.

Before my test, I went through every DRW Codility post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get a score canceled or run the clock out on the hardest question.

The Real Questions on My DRW Codility Test

I applied to DRW as a new grad SWE and got the Codility OA link with a 72 hour window. The format was confirmed: three coding questions in about 150 minutes. Here is exactly what I got.

This exact trio — a BST traversal, a DP graph problem, and a modify-in-place task — also shows up in other 2025-2026 DRW SWE candidate reports, so it is a recurring set rather than a one-off.

Question 1: BST traversal

The problem I got: I was given the root of a binary search tree and had to return all node values in ascending order as a list.

My approach: A BST yields sorted order on an inorder walk. I recursed left, recorded the node, then recursed right. This visits every node once and builds the sorted list directly.

#include <vector>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void inorder(TreeNode* root, vector<int>& out) {
    if (!root) return;
    inorder(root->left, out);
    out.push_back(root->val);
    inorder(root->right, out);
}

vector<int> solution(TreeNode* root) {
    vector<int> out;
    inorder(root, out);
    return out;
}

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

I finished this in about ten minutes and felt good going into question two.

Question 2: DP graph problem

The problem I got: I was given n nodes labeled 0 to n-1 and a list of directed edges forming a DAG, and I had to return the number of distinct paths from node 0 to node n-1, modulo 1,000,000,007.

My approach: Path counts compose along a topological order. I used Kahn's algorithm to get the order, then a DP array where dp[u] is the number of ways to reach u. Each edge u to v adds dp[u] into dp[v]. Starting dp[0] at 1 and propagating forward lands the answer at node n-1.

#include <vector>
using namespace std;

int solution(int n, vector<vector<int>>& edges) {
    vector<vector<int>> adj(n);
    vector<int> indeg(n, 0);
    for (auto& e : edges) {
        adj[e[0]].push_back(e[1]);
        indeg[e[1]]++;
    }
    vector<long long> dp(n, 0);
    dp[0] = 1;
    vector<int> q;
    for (int i = 0; i < n; i++) if (indeg[i] == 0) q.push_back(i);
    for (int i = 0; i < (int)q.size(); i++) {
        int u = q[i];
        for (int v : adj[u]) {
            dp[v] = (dp[v] + dp[u]) % 1000000007;
            if (--indeg[v] == 0) q.push_back(v);
        }
    }
    return (int)dp[n - 1];
}

Time complexity: O(n + e) | Space complexity: O(n + e)

This took me close to half an hour, but I got a clean run and moved on with the clock at roughly 80 minutes left.

Question 3: Modify code under constraints

The problem I got: I was handed a starter function that removed duplicates from a sorted array and returned the new length, and I had to modify it to run in place with O(1) extra space.

My approach: The given code used a set, which broke the space rule. I switched to a two pointer walk: a slow writer w and a fast reader r. When A[r] differs from the last written value A[w-1], I copy it forward. This compacts the unique values at the front with no extra array.

#include <vector>
using namespace std;

int solution(vector<int>& A) {
    if (A.empty()) return 0;
    int w = 1;
    for (int r = 1; r < (int)A.size(); r++) {
        if (A[r] != A[w - 1]) {
            A[w++] = A[r];
        }
    }
    return w;
}

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

I lost a lot of time second guessing whether the in place constraint allowed overwriting the input, and the rest of the window drained while I sat on it.

At least one candidate was flagged for using a Desktop Overlay on a Codility OA: the session finished normally, then an integrity review canceled the score. The answer rendered on the same screen the proctoring monitors, hidden by a basic OS layer trick rather than anything secure. AI interview tool works differently: the answer goes to my phone, a physically separate device that no screenshot or session recording can reach by design.

I chose not to use a desktop overlay for this reason: the answer would have sat on the same screen the proctoring system monitors, hidden by a basic rendering layer, and that was an uncertainty I did not want. When I hit the Q3 wall, a keyboard shortcut auto-captured the screen and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring. The approach became clear and my laptop screen stayed on the exam editor, unchanged.

DRW's Proctoring Policy for Codility

The drw codility proctoring combines identity checks, behavioral event tracking, and a post hoc AI similarity review. Codility's own support documentation lists what its Proctoring layer records during a Screen test: copy paste into the IDE with the pasted code logged in the session Timeline, tab switches, and unusually fast completion relative to expected time.

It also flags attempts to copy the task description, which Codility calls a common signal of AI tool use, and takes webcam snapshots at regular intervals plus on flagged events, kept for 30 days. Recruiters can enable continuous screen recording and video and audio capture on top.

Two newer layers raise the bar further. AI Follow-Up Questions generates three questions unique to your submitted code, each time boxed to 2 minutes with copy paste blocked and keystrokes monitored, so you explain your own solution on the spot. Device Integrity moves the test into the Codility App, a desktop client that scans for hidden AI cheating tools.

A Desktop Overlay does not defeat these signals. Codility also layers in full session replay and aggregates device, paste, and defocus events into a single risk score, so a basic overlay trick does nothing against a recorded replay of everything you typed.

5 Other Confirmed DRW Codility Questions

DRW's question bank runs wider than the three problems in any single session. I confirmed several more distinct problems reported by candidates and write-ups.

Maximal-rectangle variant

A Glassdoor review of the DRW OA lists a maximal-rectangle variant that asks for two non overlapping rectangles. The report gives no full statement or constraints, so I cannot supply working code. Practice the classic maximal rectangle first, then extend to two non overlapping regions.

Tetris variant

The same Glassdoor review mentions a Tetris variant where cleared lines do not drop the remaining blocks. No concrete rules or input format were published, so I skip the code here. Build the reflex with plain grid state simulation.

Knockout Tournament Match Counts

Prachub's DRW OA walkthrough includes Knockout Tournament Match Counts as a perfect bracket simulation. Each match eliminates one player, so the total matches equal the number of players minus one. The walkthrough reports O(n log n) for the full bracket output.

int solution(int n) {
    int matches = 0;
    while (n > 1) {
        int advancers = n / 2 + (n % 2);
        matches += n / 2;
        n = advancers;
    }
    return matches;
}

Time complexity: O(log n) per round sweep | Space complexity: O(1)

Robot Path Planning

Prachub also lists Robot Path Planning, a grid DFS Euler tour with five reported variants. The core task is to visit every free cell from a fixed start square. I wrote a DFS that marks visited cells and confirms full coverage.

#include <vector>
#include <functional>
using namespace std;

int solution(vector<string>& grid) {
    int n = grid.size(), m = grid[0].size();
    int sx = -1, sy = -1, total = 0, seen = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (grid[i][j] != '#') { total++; if (grid[i][j] == 'S') { sx = i; sy = j; } }
    function<void(int,int)> dfs = [&](int x, int y) {
        seen++;
        int dx[4] = {1,-1,0,0}, dy[4] = {0,0,1,-1};
        for (int k = 0; k < 4; k++) {
            int nx = x + dx[k], ny = y + dy[k];
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] != '#') dfs(nx, ny);
        }
    };
    dfs(sx, sy);
    return seen == total;
}

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

Solar-panel DP

A LeetCode Discuss thread documents a Codility solar panel DP with the signature solution(int[] A, int x, int Y). The task is minimum cost to reach a target sum under a cap. I built a knapsack style DP using that exact signature.

#include <vector>
using namespace std;

int solution(vector<int> A, int x, int Y) {
    vector<int> dp(Y + 1, 1e9);
    dp[0] = 0;
    for (int cost : A)
        for (int s = Y; s >= cost; s--)
            dp[s] = min(dp[s], dp[s - cost] + 1);
    return dp[x] <= Y ? dp[x] : -1;
}

Time complexity: O(|A| * Y) | Space complexity: O(Y)

LeetCode tags four more DRW questions beyond these, confirming the bank is wider than one session. DRW's SWE bank also surfaces string and array tasks on PracHub (2025-2026) such as an odd-frequency string, a digit swap, and a patient-slot assignment — same difficulty band, different shapes.

Reddit adds a third confirmed slice of the bank. A 2024 r/csMajors taker reported a DP problem, a card game simulation with N capped at 10, and a two pointer task in one DRW Codility session. The useful detail from that thread: with N that small, commenters pushed correctness over time complexity, since brute force passes.

What the DRW Codility Test Format Looks Like in 2026

As the chart below shows, the drw codility test runs on Codility with three coding questions in about 150 minutes and a 72 hour link window. DRW's own post and Glassdoor name Codility, which settles the platform question against competitors.

Competitors such as dev.to list HackerRank or CodeSignal at 70 to 120 minutes. DRW's official source and Glassdoor confirm Codility at about 150 minutes, so trust the DRW named platform over third party summaries.

How DRW's Codility Scoring Works

Codility scores DRW's OA on dual Correctness and Performance axes, each rated 0 to 100 into a composite. Candidates see no numeric score, and submissions lock the moment you submit. The locked submission means a partial solve on the last question becomes a scored outcome you cannot fix.

Why Candidates Fail the DRW Codility Assessment

Candidates fail the DRW Codility assessment through AI-tool detection and time pressure on the hardest question. Both failure modes turn a normal finish into a canceled or weak result.

AI-tool detection cancels scores

One candidate used a Desktop Overlay during the OA, finished the session normally, and later learned the score had been canceled after an integrity review. The overlay did not hide the behavioral and similarity signals Codility collects. This was a private case with no public post, but it matches the platform's documented four tier risk model.

Time-pressure on the hardest question

A Glassdoor candidate ran out of time on a maximal-rectangle variant asking for two non overlapping rectangles inside the 150 minute window. Codility's locked submission rule meant no recovery after the clock ended. The unfinished hard question converted directly into a scored failure.

How to Prepare for the DRW Codility in 3 Days

I built my plan around the 72 hour link window, since the OA arrives and must be started within three days. DRW states the exact time allowance in your invite email, so the window you actually get is the one printed there — confirm it before you schedule.

Orient on Day 1

Before writing any code, I confirmed the format: three coding questions in about 150 minutes on Codility, no numeric score shown, and a post hoc AI similarity review rather than live webcam monitoring. I also read the locked submission rule and the dual Correctness and Performance scoring into my plan, so neither was a surprise on test day.

I decided what to skip too. The confirmed DRW graph work is DAG path counting and grid traversal, never weighted shortest path, so I skipped Dijkstra and Bellman-Ford entirely.

And since the failure pattern here is AI similarity flags and time pressure, not weak fundamentals, I spent no time on esoteric competitive programming tricks and drilled finishing clean under the clock instead.

Drill on Day 2

I drilled the confirmed recurring categories directly: inorder BST traversal for sorted output, Kahn's algorithm path counting on a DAG with a modulo, and two pointer in place compaction under an O(1) space constraint. Each maps to a real DRW question, so every rep aimed at a shape I actually expected rather than a generic LeetCode list.

In the days before the OA, I used the Prep Agent from interviewfox.ai over WhatsApp and SMS, sent it the confirmed DRW Codility question patterns, and got a personalized drill plan and strategy back. It was one practical tool among several, not a pitch.

Simulate on Day 3

I sat one full timed mock on the Codility sample test at the real 150 minute limit to lock my pacing. Then I kept the final hours before the test light, a review of my own notes with no new problems, so I walked in rested with my pacing already grooved.

What Happens After You Submit the OA

After you submit, DRW moves candidates to a zoom technical interview of about 45 minutes, then an onsite final, then an offer. The SWE superday is heavy on algorithmic DP, so I grilled recursive and iterative DP before the onsite.

DRW SWE median total comp sits near $300,000 in the US, and the average hiring process runs about 24 days.

DRW Officially Uses Codility, Not HackerRank or CodeSignal

DRW officially runs its SWE OA on Codility, not HackerRank or CodeSignal, a point competitors often mislabel. DRW's own post and careers page name Codility, and Glassdoor confirms the same platform. Codility also shows no score and locks submissions after submit, a bite generic DRW OA articles miss.

One caveat: DRW's quant-trading and QR intern roles use a separate quantitative OA (often six math and probability questions in roughly 45 minutes, not on Codility). This guide covers the SWE coding OA on Codility specifically.

FAQ

Does Codility show my DRW score?

Codility shows candidates no numeric score. Submissions lock after submit, so candidates cannot revise.

How long is the DRW Codility link valid?

The OA link stays open for 72 hours from receipt. Start it early to use the full window.

What comes after the DRW Codility OA?

DRW moves candidates to a zoom technical interview, then an onsite final, then an offer.

What do Reddit threads say about the DRW OA?

r/csMajors threads confirm the Codility OA across 2024-2026. A 2024 taker reported a DP problem, a card game with N between 1 and 10, and a two pointer task, with commenters advising correctness over time complexity on the small-N question. A 2026 SWE thread matches the format I got.

Is the DRW OA the same in 2025 and 2026?

DRW has run the Codility OA across both years. The format held at three questions and 150 minutes.

Can I use an AI tool or invisible app during the DRW Codility OA?

Desktop overlay tools place the answer on your screen through a basic OS layer trick, and their risk exposure is not fixed because proctoring keeps adding capabilities. interviewfox.ai instead pushes the answer to your phone, a physically separate device that no screenshot or session recording can reach.

If you use AI help during the OA, that dual device architecture removes the answer from your screen entirely.