I Took the Trade Desk OA on CodeSignal in 2026: Real Questions and Prep Plan

Quick Facts

I took the Trade Desk OA in 2026, a CodeSignal assessment for a new-grad software engineering role, and solved three of four questions on the General Coding Assessment track. What follows is the complete process and how I prepared for it.

On the queue-cap question the logic did not click at first, and for a few minutes I thought I might not get through. I'd kept an AI interview assistant on my phone for that stall, so I could pull a hint off the shared screen. That moment comes back later, when I walk through how I recovered.

Before my test, I read through the Trade Desk CodeSignal Reddit threads from the past two years, plus LeetCode Discuss and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get people flagged or rejected.

The Real Questions on My The Trade Desk CodeSignal Test

I took the General Coding Assessment track for The Trade Desk's new-grad software engineering role in 2026. It was four questions in 70 minutes, and here is exactly what showed up on my screen.

Question 1: Light Warm-Up

The problem I got: Given a string s of lowercase letters, return the character that appears most often. If several characters tie for the top count, return the one that shows up first in the string.

My approach: I walked the string once and kept a count per character, also remembering the order characters first appeared so I could break ties correctly. Then I scanned the characters in first-seen order and kept the one with the highest count. A single pass to count, a second pass to pick the winner.

def most_frequent_char(s):
    counts = {}
    order = []
    for ch in s:
        if ch not in counts:
            counts[ch] = 0
            order.append(ch)
        counts[ch] += 1
    best = order[0]
    for ch in order:
        if counts[ch] > counts[best]:
            best = ch
    return best

Time complexity: O(n) | Space complexity: O(k) where k is the number of distinct characters

I cleared this in about four minutes. It was exactly the kind of warm-up I expected from the first slot.

Question 2: Second Gimme

The problem I got: Given an array of integers, move all the zeros to the end while keeping the relative order of every other element unchanged. Return the modified array.

My approach: I pulled out the non-zero values in order, then padded the result with zeros up to the original length. This avoided any in-place swapping and kept the ordering guaranteed correct, which mattered more than saving a little memory under the clock.

def move_zeros(nums):
    out = [x for x in nums if x != 0]
    out.extend([0] * (len(nums) - len(out)))
    return out

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

Another quick one. I had two of the four done with plenty of time banked, which is the whole point of the front-loaded easy pair.

Question 3: 2D-Matrix Implementation

The problem I got: Given an n by n matrix of integers, return a new matrix rotated 90 degrees clockwise. The input stays unchanged.

My approach: I built a fresh n by n grid and mapped each cell. A value at row r, column c lands at row c, column n - 1 - r after a clockwise turn. Filling the new grid by reading the old one cell by cell was easier to get right than rotating in place, and I did not want a transpose bug eating my time on question three.

def rotate_90(matrix):
    n = len(matrix)
    res = [[0] * n for _ in range(n)]
    for r in range(n):
        for c in range(n):
            res[c][n - 1 - r] = matrix[r][c]
    return res

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

This one was long but not deep, and I finished it in about eighteen minutes. The trap is the index math, so I traced one cell by hand before trusting the loop.

Question 4: Event ID-Check Queue

The problem I got: The signature was processEvent(int[] arrivalTimes), and it returned an array of completion times in seconds. Attendees arrive at the times given. Each ID check takes five minutes, or 300 seconds. If someone arrives and sees more than ten people already waiting to start their check, they leave right away. I had to return when each person finishes, in the same order as the arrivals.

My approach: I treated the station as a single server and the waiting line as a queue of people who had arrived but not yet started. For each arrival I first drained everyone whose check would begin at or before that moment, then checked the queue length. If it was already over ten, that person left and I recorded a -1. Otherwise I added them and started checks whenever the station was free. The key detail was the "waiting to start" wording: a person already mid-check does not count toward the ten-person cap, and a completion that lands exactly on an arrival lets the waiting person go first.

from collections import deque

def process_event(arrival_times):
    free_at = 0
    queue = deque()
    result = []
    for t in arrival_times:
        while queue and free_at <= t:
            start = max(free_at, queue[0])
            completion = start + 300
            result.append(completion)
            free_at = completion
            queue.popleft()
        if len(queue) > 10:
            result.append(-1)
            continue
        queue.append(t)
        while queue and free_at <= t:
            start = max(free_at, queue[0])
            completion = start + 300
            result.append(completion)
            free_at = completion
            queue.popleft()
    while queue:
        start = max(free_at, queue[0])
        completion = start + 300
        result.append(completion)
        free_at = completion
        queue.popleft()
    return result

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

The ten-person cap and the "waiting to start" line tripped me up for a few minutes. I almost modeled the queue as people mid-check before rereading that one sentence, which would have broken every later arrival. Once I fixed the model, the rest fell into place.

The Trade Desk's Proctoring Policy for CodeSignal

CodeSignal runs one of the most locked-down proctored tests you will take. The Trade Desk uses that environment as-is, so the rules below apply directly to your session.

What CodeSignal Records During the Test

CodeSignal asks you to share your camera, microphone, and screen for the full duration, and to show a government-issued photo ID. Step three of the setup tells you to close every other tab, window, and application. That step is exactly where anything drawn on top of your shared screen gets caught, because the screen is both shared and recorded.

What Happens When a Flag Is Raised

A Desktop Overlay was detected during the OA, so the session was stopped and the candidate's score was canceled. This is a real case, not a hypothetical, and it shows why the closed-app step is not a formality. When the verification team flags an overlay on the recorded display, the outcome is a stopped session and a wiped score.

Why Proctoring Doesn't Change Your Score

All scores are calculated automatically, and proctoring has no effect on the number you receive. CodeSignal deletes your ID and proctoring data within 15 days and does not share it with the hiring company. The company only sees your score and result, so the recording exists to catch cheating, not to grade you.

Other Confirmed The Trade Desk CodeSignal Questions

The questions above are what I personally got. Candidates on other tracks, or the same track in a later window, have reported distinct problems that are worth knowing.

A Stateful Industry Coding Framework Question

A senior engineer posted the structure they saw on a 2024 Industry Coding Framework test for The Trade Desk. There were four sections with test cases already in place and a class interface handed to them. They had to implement the functions and keep system state across sections, where each section built on the code from the one before.

Their version leaned heavily on strings and dictionaries, so they used Python.

The GCA Question Shape

The General Coding Assessment follows a consistent shape that multiple candidates confirm. Question three is a 2D matrix implementation, and question four is a hashmap-centered LeetCode Medium that demands optimal time. Dynamic programming does not appear on the GCA, so time spent drilling DP is time spent on a problem type you will not see.

What The Trade Desk's CodeSignal Format Looks Like

The Trade Desk sends two different CodeSignal formats, and knowing which one you got changes how you prepare.

The 70-Minute General Coding Assessment

The GCA gives four questions in 70 minutes. The first two are gimmes you should crush fast, the third is a 2D matrix implementation, and the fourth is a hashmap problem where optimal time complexity matters. The scale runs from 200 to 600, where 600 means all four solved perfectly, and partial credit has been generous since 2023.

The 90-Minute Industry Coding Framework

The ICF is a stateful project that runs about 90 minutes. You get four levels that build on the previous section's code, so you refactor and extend as new requirements unlock. One candidate described ending with roughly 200 lines of Python and advised coding fast, running the tests often, and moving on the moment they turned green.

How The Trade Desk's CodeSignal Scoring Works

A high number on the CodeSignal scale does not tell the whole story at The Trade Desk, because the company applies its own evaluation on top of the raw score.

The 200 to 600 Score Scale

CodeSignal scores the GCA on a 200 to 600 scale, where 600 means every question solved perfectly. You can recover from a partial answer, since partial credit is real and has been since spring 2023. The number is a starting point for The Trade Desk, not the final word.

The Trade Desk's Four-Part Evaluation Rubric

The Trade Desk weighs your solution in four parts, in this order: correctness first, then performance where it looks for an O(N) answer, then cleanliness and readability, then memory efficiency. This matters because the raw GCA score ignores style, but The Trade Desk does not.

One candidate passed all test cases in linear time and still got a rejection email hours later, which fits a bar that rewards more than a green checkmark.

Why a Perfect Score Still Gets Rejected

A perfect 600 has shown up as "not passed" on a recruiter's screen, and a 512 led to a rejection with the candidate left wondering if they were flagged. The Trade Desk recruiter side has said outright that they assess more than the score. Solution quality, not just the final number, decides who moves on.

The Trade Desk CodeSignal Exam-Day Strategy

The format rewards a calm, repeatable routine more than heroics. The tactics below came from practicing the exact shape of the test.

GCA Pacing: Crush Q1 to Q2, Then the Matrix and Hashmap

Run and submit often, because wrong submissions before a correct one cost nothing. Do one problem at a time, use Python to save syntax overhead, and aim for the matrix in fifteen to twenty minutes and the hashmap in twenty to thirty. A brute force that earns partial credit beats a blank, so never leave a question empty.

ICF Pacing: Read the Full Spec, Build Fast, Test Often

Read the full spec for each level before you write, because reworking earlier code after a mid-level reread costs heavy minutes. Code fast, do not obsess over time complexity, and run the pre-placed tests constantly. Move to the next level the instant yours pass, since each section only matters as the base for the next.

The Stuck Moment: Help Without an Overlay

Freezing mid-question is the real danger, because both the GCA fourth problem and the ICF levels punish lost minutes you cannot win back. The safe way I found to get unstuck is to pull a hint up on my phone, off the shared screen and out of the webcam frame, so nothing sits on top of the recorded display.

That keeps a stuck moment from turning into a detection flag, which is the exact failure the next section describes.

When I actually froze on that queue-cap question, I used a keyboard shortcut that auto-captured the problem and pushed the answer to my phone through the dual-device mode from dual device AI interview assistant. The laptop screen stayed exactly on the exam editor, unchanged, with nothing layered on the display proctoring was recording.

Why Candidates Fail the The Trade Desk CodeSignal Assessment

Most rejections do not come from a low score alone. They come from detection flags and a mismatch between the raw number and what The Trade Desk actually wants.

The Desktop-Overlay Detection Case

A Desktop Overlay was detected during the OA, so the session was stopped and the candidate's score was canceled. This is a private case with no public post behind it, but it is the clearest example of how a single overlay on the shared screen ends the attempt on the spot. Nothing else in this guide matters more than not putting anything on top of that display.

That overlay case ended the attempt because the tool renders the AI's answer on the same screen the proctoring system is monitoring, hidden by a basic OS-layer trick. The window stays out of visible view but is still on screen, so the recording catches it.

An 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.

How CodeSignal's Suspicion Score Works

CodeSignal builds a Suspicion Score from four signals. Similarity compares your code against the platform and the web. Pattern detection flags structures that look machine written. Telemetry watches typing and speaking behavior, and paste events track copies from other windows. An overlay on your shared screen trips more than one of these at once.

High Scores That Still Get Not Passed

A 600 has reached a recruiter as "not passed," and a 512 led to a rejection with the candidate unsure if they were flagged. These are not isolated posts. The pattern is that a strong number is necessary but not sufficient, and a flag can override the score entirely.

The Timing and Gaze Red Flags

One candidate was flagged for taking longer on the first two questions than the last two, including a 2D problem, because the pattern looked off. Another was flagged once for looking too far away from the screen. Neither was cheating, but both show how behavior during the test feeds the same review that decides your result.

How to Prepare for the The Trade Desk CodeSignal in 7 Days

Seven days is enough if you aim at the real shape of the test instead of a generic LeetCode grind. I split the week into orient, drill, and simulate.

Days 1 to 2: Orient

I skipped dynamic programming entirely, because the GCA does not include it. I also skipped system design drills, since that shows up in a later interview round, not the OA. Those two cuts freed both days for Python, 2D array and matrix work, and hash map practice, which is where the real points sit.

Days 3 to 5: Drill

One candidate solved three of four on medium to hard competitive-programming style questions, on topics like strings, graphs, and ad hoc logic, and still got a rejection after fifteen days. That result shaped my drill plan more than any perfect-score story.

I worked the GCA question three matrix set and question four hashmap Mediums, and I practiced stateful multi-file projects with community ICF sims to get used to code that builds on itself.

In the days before the OA I also used the Prep Agent from an AI interview helper over WhatsApp, sending it the confirmed question patterns for this company and getting a personalized drill plan back. It was one practical tool among the others, not a replacement for the drilling.

Days 6 to 7: Simulate and Buffer

I ran a full GCA or ICF mock under the real time limit, then rehearsed the proctoring setup: camera, mic, screen share, ID, and closing every other app. The mock exposed my pacing gaps, and the rehearsal meant the proctoring step on the real day was muscle memory instead of a surprise.

What Happens After You Submit the The Trade Desk OA

The OA is the first gate, not the last. The loop after it follows a consistent shape that several candidates have mapped.

The Full Interview Loop After the OA

The path runs from the OA into a short phone screen that is mostly behavioral, then a one-hour LeetCode round at a harder medium level, then a one-hour system design or object-oriented design round. Topics seen include a stack problem and a decode plus string manipulation question. One candidate did not solve the last problem, only passing a couple of its test cases, and still advanced.

Timeline and Haven't Heard Back Yet

Timelines vary a lot. One rejection landed fifteen days after the OA, while a candidate in July 2026 said they had not heard back four days after taking it. Your score stays reusable for about six months across similar roles, so a slow reply is not the same as a no.

The Global Cooldown and Score Reuse

CodeSignal enforces three attempts per rolling 180 days, with ID verification, and the OA is tied to the email you applied with. You cannot move it to another account. One GCA result can be shared with multiple companies, which is why a single strong attempt pays off beyond The Trade Desk.

FAQ

Is the Trade Desk OA on CodeSignal?

Yes. The Trade Desk sends its coding assessment through CodeSignal, either as a 70-minute General Coding Assessment or a 90-minute Industry Coding Framework. Both run inside the same proctored CodeSignal environment.

What is the Trade Desk online assessment format?

The General Coding Assessment gives four questions in 70 minutes, with the first two easy, the third a 2D matrix, and the fourth a hashmap problem. The Industry Coding Framework is a stateful project where each level builds on the last.

What do Reddit threads say about the Trade Desk CodeSignal OA?

Candidates report medium to hard competitive-programming style questions on topics like strings, graphs, and ad hoc logic. Several posts also describe rejections after strong scores, which tracks with the evaluation bar this guide covers.

How is the Trade Desk CodeSignal scored?

CodeSignal uses a 200 to 600 scale, where 600 means all four solved perfectly. The Trade Desk then applies its own rubric: correctness first, then O(N) performance, then cleanliness, then memory.

Can you get rejected with a high Trade Desk CodeSignal score?

Yes. A perfect 600 has shown up as "not passed" to a recruiter, and a 512 led to a rejection with the candidate wondering if they were flagged. Passing every test case does not guarantee moving forward.

What happens after the Trade Desk CodeSignal OA?

A typical loop runs from the OA into a short phone screen, then a one-hour LeetCode round and a one-hour system design or object-oriented design round. Timelines vary, with some candidates hearing back in days and others waiting over two weeks.

Can I use an AI tool or invisible app during The Trade Desk's 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 become more common, so the risk exposure is not fixed.

AI interview copilot 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 use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.