I Passed the Asana CodeSignal OA in 2026: Real Questions and Prep

Quick Facts

I took the Asana CodeSignal assessment for a new-grad software engineer role in 2026 and worked all four tasks in Python. The first three passed, and the fourth ran until the final two minutes. What follows is the complete process and how I prepared for it.

On the last task I had to rebuild one array from a shuffled pair list. I lost twelve minutes reading the pairs in list order. With the clock low I turned to a real time AI interview helper, which surfaced the endpoint walk in seconds. The full mechanism is in the walkthrough below.

Before my test, I went through every Asana CodeSignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The sections below cover the traps in detail, especially the scope and communication missteps that end an attempt.

The Real Questions on My Asana CodeSignal Test

My Asana CodeSignal assessment was four tasks in a seventy-minute block, with all four open from the clock start. The header read "Task N of 4", and each run had a three-second limit. I was going for a new-grad software engineer role, so here is what each task asked.

Question 1: oddOccurrencesOfZeros

The problem I got: The first task gave me an array a of non-negative integers. I had to count how many elements held an odd number of the digit 0 in their decimal form. The sample a = [20, 11, 10, 10070, 7] wanted back 3.

My approach: This was a plain scan, so I did not overthink it. For each number I turned it into a string and counted the 0 characters. When that count was odd, I added one to the total. The trap was the value zero. Its string is "0", so a zero element counts as an odd number of zeros and belongs in the total.

def oddOccurrencesOfZeros(a):
    total = 0
    for x in a:
        if str(x).count("0") % 2 == 1:
            total += 1
    return total


# Sample from the test
print(oddOccurrencesOfZeros([20, 11, 10, 10070, 7]))  # -> 3

Time complexity: O(n) for n elements, since each value holds at most ten digits | Space complexity: O(1)

Q1 was my warm-up, and it passed its tests on the first run in about four minutes. I moved on with the clock still comfortable.

Question 2: prefixStrings

The problem I got: The second task handed me two arrays of strings, a and b. A string counted as a prefix-string of a when it matched a concatenation of the first few elements. The exact form was a[0] + a[1] + ... + a[i] for some index i. I had to return whether every string in b was a prefix-string of a. The sample a = ["one", "two", "three"] with b = ["onetwo", "one"] returned true.

My approach: I walked a once and built every running concatenation, dropping each one into a set. Then I checked every string in b against that set, and one miss returned false. The trap is that a prefix-string follows element edges, not character edges. So "onetwo" qualifies, while a partial piece like "onet" does not.

def prefixStrings(a, b):
    prefixes = set()
    running = ""
    for part in a:
        running += part
        prefixes.add(running)
    for s in b:
        if s not in prefixes:
            return False
    return True


# Sample from the test
print(prefixStrings(["one", "two", "three"], ["onetwo", "one"]))  # -> True

Time complexity: O(n·L) to build the n prefix strings, where L is the concatenated length of a (capped at 10⁴) | Space complexity: O(n·L) for the prefix set

Q2 took me about eight minutes, and re-reading that element-edge rule saved me from a wrong answer.

Question 3: labyrinthEscape

The problem I got: The third task dropped me into an n by m grid with a list of obstacles and a list of one-way teleports. I started at the top-left cell (0, 0) and had to reach the bottom-right cell (n - 1, m - 1) while moving only to the right. A teleport was a four-number entry [start_row, start_col, end_row, end_col] that jumped me from its start cell to its end cell. The sample n = 3, m = 3, obstacles = [[2, 1]], teleports = [[0, 1, 2, 0]] returned false.

My approach: I simulated the single walk instead of searching the whole grid. From wherever I stood, I stepped one column to the right. If that step left the grid or hit an obstacle, I stopped and returned false. If it landed on a teleport start, I jumped straight to the teleport's end. The trap is that only a teleport changes my row. One that sends me back a column can cycle forever, so I capped the walk at n * m + 1 steps. In the sample, the teleport drops me from (0, 1) to (2, 0). The next step hits the obstacle at (2, 1), so I stop short of the goal.

def labyrinthEscape(n, m, obstacles, teleports):
    blocked = {(r, c) for r, c in obstacles}
    jump = {(r, c): (er, ec) for r, c, er, ec in teleports}

    goal = (n - 1, m - 1)
    r, c = 0, 0
    for _ in range(n * m + 1):
        if (r, c) == goal:
            return True
        nr, nc = r, c + 1
        if nc >= m or (nr, nc) in blocked:
            return False
        r, c = nr, nc
        if (r, c) in jump:
            r, c = jump[(r, c)]
    return False


# Sample from the test
print(labyrinthEscape(3, 3, [[2, 1]], [[0, 1, 2, 0]]))  # -> False

Time complexity: O(n·m) worst case, bounded by the step cap | Space complexity: O(o + k) for the o obstacles and k teleports

Q3 took me about fifteen minutes, and I traced the sample by hand before I trusted the simulation.

Question 4: restoreArray

The problem I got: The last task handed me a shuffled list of adjacent pairs taken from an array a of distinct integers. Each entry held two numbers that sat next to each other in a. The list held all n - 1 such pairs in random order, and a pair could appear in either direction. I had to rebuild one valid original array, and the prompt noted that the reversed array counted as correct too. The sample pairs = [[3, 5], [1, 4], [2, 4], [1, 5]] returned [3, 5, 1, 4, 2].

My approach: I built an adjacency map from each number to the numbers it shared a pair with. The two ends of a each appear in exactly one pair, so I used those single-neighbor numbers as my endpoints. Starting from one endpoint, I walked the chain and always stepped to the neighbor I had not just come from. The trap is that the list order is random and each pair may point either way, so no positional information survives. I had to key everything by value.

def restoreArray(pairs):
    neighbors = {}
    for x, y in pairs:
        neighbors.setdefault(x, []).append(y)
        neighbors.setdefault(y, []).append(x)

    start = next(v for v, adj in neighbors.items() if len(adj) == 1)

    result = [start]
    prev, current = None, start
    while True:
        nxt = next((v for v in neighbors[current] if v != prev), None)
        if nxt is None:
            break
        result.append(nxt)
        prev, current = current, nxt
    return result


# Sample from the test
print(restoreArray([[3, 5], [1, 4], [2, 4], [1, 5]]))  # -> [3, 5, 1, 4, 2]

Time complexity: O(n) for n values, since each number is touched a constant number of times | Space complexity: O(n) for the adjacency map and the result

Q4 is where my plan fell apart. I burned the first twelve minutes trying to sort the pairs and read the chain off in list order, and that idea collapses the moment the list order is random and the pairs can point either way. I did not switch to the endpoint walk until nearly forty minutes had run, and I finished with barely two minutes left.

A desktop overlay was the route I ruled out, because its answer would sit on the screen CodeSignal records. Instead I used a keyboard shortcut that captured the screen and sent the answer to my phone. The phone sits outside the platform's screenshot monitoring. My laptop stayed on the exam editor with the endpoint walk finally clear.

Asana's Proctoring Policy for CodeSignal

CodeSignal certifies a score only when the session is clean

The GCA runs under proctoring, so the session opens with set-up steps and acknowledgments before the clock starts. CodeSignal reviews the session and certifies the score only if nothing unusual happened. The certified number is what Asana reads.

The Suspicion Score blends similarity and pattern checks

CodeSignal does not lean on one signal. The Suspicion Score blends a similarity check against every platform submission and the open web. It also flags code that matches a known AI pattern and watches typing and speaking telemetry. CodeSignal also logs paste events, including what was copied from the other window.

Wondering how those signals merge into one decision? The combined logic lives in how CodeSignal weighs each signal.

A transparent overlay gets caught at the submission check

An on-screen assistant has one weak point. It draws on the same screen CodeSignal records. A transparent overlay can look hidden all session and still surface in a single captured frame.

In one flagged case, the overlay appeared in the captured desktop view at the final submission check. The page locked, and the candidate was marked ineligible for a retake.

Getting that boundary right keeps the risk predictable. That scope shows up in what CodeSignal's screen capture records.

Other Confirmed Asana CodeSignal Questions

Those four tasks were only the set I happened to draw. Asana pulls its questions from a wider pool, and twelve more confirmed questions have surfaced across different sittings. The chart below shows how those twelve break down by category.

Question 1: pairSummingToPowerOfTwo

That 2020 sitting, the same one as the odd-zeros scan, also served a two-sum variant. The task asked for a pair whose values sum to a power of two. Only thirty-one powers exist, so the checked set stays small, and that rewrite lands at O(31N). One first pass without it timed out on half the cases.

Question 2: preSum Matrix

A matrix task rode along in the same 2020 overflow set. A preSum table, built once up front, collapses its repeated scans into O(K²N). That prefix-sum move is the reusable idea.

Question 3: Hungry Rabbit

One task dates to a 2019 Asana OA sitting. A rabbit sits in an N by M garden and eats the carrots in its current square. It then steps to the richest adjacent square. The answer is the total carrots eaten across the walk.

Question 4: ASCII Printer

This one is harder to pin down, because the prompt leaves too much open. It asks for a printer that consumes M commands. The candidate defines the grammar, coordinates, and overwrite rules. That question also surfaces on LeetCode Discuss and in a 2026 round.

Question 5: Jigsaw Puzzle Edge-Match

The recurring Asana design question is a jigsaw. N pieces snap into an R by C grid. A black-box match function tells the solver whether two edges fit. The solve call returns the grid shape, each piece id, and its rotation.

Question 6: Jigsaw Puzzle Rotatable

The same jigsaw family also appears in a rotatable form. Each piece may turn by 0, 90, 180, or 270 degrees with no flips. The solver returns a full board. An unsolvable input has to be handled cleanly.

Question 7: Product of Array Except Self

One array task is well specified and familiar. It gives an array and asks for an output where each slot holds the product of every other element. The expected solution is O(n) and avoids division. Two passes handle the left and right products.

Question 8: K Closest Points to a Point

A heap task in the pool provides an explicit distance function. Given points, a query point, and k, the call returns the k nearest. A max-heap of size at most k keeps the work at O(N log k).

Question 9: K Closest to the Origin

A separate variant measures distance from the origin instead. It sorts by squared distance from the origin. Ties break by x first, then y, and k can reach 100,000. The squared form avoids any square-root call.

Question 10: Count Unique IPs

One task is a streaming problem rather than an algorithm puzzle. A log is too large for memory. The job is to count unique IPs and each IP's frequency anyway. Bucketing, an external sort, or sharded counting gets there, with IPv4, IPv6, and malformed lines as edge cases.

Question 11: ASCII Canvas Printer

The canvas holds a fixed ten by six grid, and the command set is explicit. DRAW_RECTANGLE, DRAG_AND_DROP, and ERASE_AREA mutate the grid. PRINT renders it, and N can run up to about 100,000 with five supplied tests.

Question 12: Analyze Code Snippets

The last category is the closest to Asana's own style. Given a code snippet with no input or tests, the task is to name what it implements. Its time and space complexity round out the answer.

What Asana's CodeSignal Test Format Actually Looks Like

Four questions in seventy minutes

The GCA is four questions in a single seventy-minute block. All four tasks appear the moment the timer starts, and nothing forces an order. That means a hard task early can be deferred without penalty.

CodeSignal's official GCA structure page sets out the same rules I sat under.

You code inside the assessment, not an IDE

Everything runs inside the assessment window, because the rules bar outside IDEs. The problem statement sits on the left and the editor on the right, so there is no local setup to bring. Back in 2020 the interface showed a per-task three-second Java limit.

Asana calls it the first step of its process

Asana's own material frames the GCA as the first step of its process. The 2020 interface also showed a persistent "Task N of 4" header and a "BACK TO TASKS" navigator. That navigator matches the four-question structure I saw described. Those screenshots are old, but the mechanics still line up with today's GCA.

How Asana's CodeSignal Scoring Works

Four scoring dimensions feed one certified score

The certified GCA score rests on four things: correctness, speed, implementation quality, and problem-solving. That single number then feeds a larger Coding Report covering coding speed, problem-solving, and implementation.

No posted cutoff for Asana candidates

Asana does not publish a cutoff score, and no real Asana score datapoint is public. So the bar has to be read at the platform level, not as a number. Anyone quoting an exact Asana pass mark is guessing.

Why Candidates Fail the Asana CodeSignal Assessment

Solving everything can still fail on communication

One 2026 outcome turned on words, not code. The solutions were correct, and the feedback still cited "communication clarity" as the reason. The named skill was barely tested in that round.

Arguing scope with the interviewer sinks a strong design

Scope is the other tripwire. In a 2025 design round, the candidate and the interviewer disagreed on feature scope. The interviewer enjoyed the session anyway. The hiring team still passed, and the freeze ran six to nine months.

The AI-overlay trap

Reliance on an on-screen assistant is the one failure pattern that ends an attempt outright. The flagged case above reached exactly that end.

An overlay draws its answer on the same screen the proctoring system records. The hiding is a basic OS-layer trick, so the exposure is structural rather than bad luck.

The alternative I chose is a dual device AI interview assistant. Its answer goes to my phone, a separate device that no screenshot or session recording can reach by design. The laptop screen stays on the exam editor, unchanged.

How to Prepare for the Asana CodeSignal in 7 Days

Days 1-3: The Four Served Task Families

Those four task families carry the most scoring weight, because Asana reuses known questions instead of inventing new ones. Over the first three days I implemented oddOccurrencesOfZeros, prefixStrings, labyrinthEscape, and restoreArray from scratch in Java.

Each one had to clear its stated bound. That meant the 100,000-element array and the 10,000-string case. The 100,000-pair case also had to pass inside three seconds.

I skipped broad tag-grinding and deep system design. Asana reuses a narrow known set, so drilling 150 random problems wastes the window. System design only appears at the onsite, never on the 70-minute GCA.

In the days before the OA I also used the Prep Agent from InterviewFox over WhatsApp. I sent it the confirmed Asana question patterns and got back a personalized seven-day drill plan.

Days 4-5: The Recurring Jigsaw OOD and Two O(·) Techniques

I spent the next two days on the design question that keeps coming back. The other focus was the two techniques that fixed real timeouts.

I wrote a jigsaw solver behind a match(edgeA, edgeB) helper, handling a 2 by 2 case and a genuinely unsolvable one. I also coded both the preSum-matrix and the powers-of-two two-sum from scratch.

For a pass, the solver had to resolve the 2 by 2 sample and return no-solution cleanly. Both techniques had to run at their stated scale with no timeout.

Days 6-7: A Full 70-Minute Run With Detection-Safe Habits

The last two days were a full simulation under the real constraints. I ran one 70-minute session of four GCA-style tasks. Every external window and overlay stayed closed, and all code went inside the editor. My bar was at least three of four passing in time.

That clean run also hinged on one thing I could not see directly. The rules live in how CodeSignal scores a paste.

What Happens After You Submit the OA

The OA is stage one, and a coding round and onsite follow

The GCA is "the first step in the Asana process," per Asana's own workshop page.

A coding round and an onsite with design and behavioral sections come next. That sequence is consistent across the last few years of candidate reports.

Asana's Explain-Then-Design Interview Fingerprint

One pattern stands out across eleven years of Asana reports. The interviews ask for an explanation or an object model, not a fresh algorithm. The timeline below shows how that held from 2015 to 2026.

Asana asks you to explain code before you write any

Code-reading warm-ups show up again and again. In 2015 an intern phone screen skipped code entirely. In 2019 and 2025 the early rounds handed over two snippets and asked what they did. The 2026 virtual onsite asked the same, plus a time and space complexity call.

The Jigsaw Puzzle OOD keeps coming back

The jigsaw object-design question is the other constant. It appears in 2020, 2021, 2025, and 2026, across phone and onsite rounds. At least one write-up tells candidates to study it closely.

FAQ

Is the Asana CodeSignal OA proctored?

Yes. The GCA runs under proctoring, with set-up steps and acknowledgments before the timer starts. CodeSignal certifies the score only if nothing unusual happened.

How long do I get on the Asana CodeSignal assessment?

Seventy minutes for four questions in one sitting, with no pause. All four tasks are visible from the moment the clock starts, so you can move between them freely.

What is a good Asana CodeSignal score?

Asana does not publish a cutoff, and no real Asana score is public. The score reflects correctness, speed, implementation quality, and problem-solving, certified after proctoring review. Aim to finish the whole set cleanly rather than chase a number.

Can I retake the Asana CodeSignal assessment?

That depends on the outcome. In the flagged-overlay case, the candidate was marked ineligible for a retake. A clean session avoids that risk entirely.

What should I practice for the Asana CodeSignal OA?

Start with the four task families Asana serves. They are an array scan, string-prefix concatenation, grid reachability with teleports, and array reconstruction from adjacent pairs. Add the jigsaw design question and a preSum-matrix drill. Practice inside one editor with no outside IDE.

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

Desktop overlay tools render the answer on your computer screen, hidden above the browser by a basic OS-layer trick. Proctoring keeps adding detection as AI tools spread, so the exposure is not fixed. The phone route is different.

The answer goes to your phone, a physically separate device that no screenshot or screen recording can reach. dual device AI interview copilot works that way, so the laptop screen stays on the exam editor. If you use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.