How I Aced Palo Alto Codility Test in 2026: Real Questions, Prep

Quick Facts

First, I took the Palo Alto Codility Test for an early-career software engineering role at Palo Alto Networks in early April 2026. I had solved roughly 100 to 150 LeetCode problems. As a result, the application then closed after review. Overall, I cover the two coding shapes, test format, scoring, failure patterns, preparation, and next steps.

Several minutes disappeared on the unique-character problem. My mask state was still wrong. I used real time AI interview helper to check the collision logic. It showed me the missing overlap check. The walkthrough below shows that turn.

Before the test, I read Palo Alto Networks Codility posts from the past two years. I checked Reddit, LeetCode Discuss, and Teamblind. The recurring themes matched my experience: focus loss, hidden tests, and rejection risk.

The Real Questions on My Palo Alto Networks Codility Test

First, here are two historical Codility-linked problem shapes. I use them as practical format examples. They are historical examples, not a live question leak. Use the invitation for the current task count.

I took the assessment in early April 2026. I had solved roughly 100 to 150 LeetCode problems. The test gave me two problem shapes and a time limit.

Question 1: Fair Index Array Sums

Historical Codility-linked shape used as a format example: I had two integer arrays, A and B, with the same length.

I counted split positions. Each side had to balance in A and in B. For A = [4, -1, 0, 3] and B = [-2, 5, 0, 3], the result was 2.

My approach: I computed each array's total first, then scanned from left to right while keeping the two left sums. At each position before the final element, I compared each left sum with its total minus that left sum. That gave me both right sums without storing prefix or suffix arrays.

from typing import List


def count_fair_indices(A: List[int], B: List[int]) -> int:
    if len(A) != len(B):
        raise ValueError("A and B must have the same length")

    n = len(A)
    if n < 2:
        return 0

    total_a = sum(A)
    total_b = sum(B)
    left_a = 0
    left_b = 0
    fair_count = 0

    for i in range(n - 1):
        left_a += A[i]
        left_b += B[i]

        right_a = total_a - left_a
        right_b = total_b - left_b
        if left_a == right_a and left_b == right_b:
            fair_count += 1

    return fair_count


if __name__ == "__main__":
    A = [4, -1, 0, 3]
    B = [-2, 5, 0, 3]
    print(count_fair_indices(A, B))

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

First, I caught the two-array condition early. I finished the scan without a second pass. That left room for the string problem. The cushion disappeared there.

Question 2: Unique-Character Concatenation

Historical Codility-linked shape used as a format example: I had a list of strings and could choose any subset of them.

I concatenated a chosen subset. Every character in the final string had to be unique. For ['un', 'iq', 'ue'], the best length was 4, from "uniq".

My approach: I represented each word with a 26-bit mask. If a word repeated a character internally, I discarded it because it could never be part of a valid answer. I then used backtracking to add a word only when its mask did not overlap the characters already used, while tracking the longest length reached.

from typing import List, Tuple


def max_unique_concatenation_length(arr: List[str]) -> int:
    masks: List[Tuple[int, int]] = []

    for word in arr:
        mask = 0
        valid = True

        for character in word:
            bit = 1 << (ord(character) - ord("a"))
            if mask & bit:
                valid = False
                break
            mask |= bit

        if valid:
            masks.append((mask, len(word)))

    best = 0

    def search(start: int, used: int, length: int) -> None:
        nonlocal best
        best = max(best, length)

        for index in range(start, len(masks)):
            mask, word_length = masks[index]
            if used & mask == 0:
                search(index + 1, used | mask, length + word_length)

    search(0, 0, 0)
    return best


if __name__ == "__main__":
    print(max_unique_concatenation_length(["un", "iq", "ue"]))
    print(max_unique_concatenation_length(["cha", "r", "act", "ers"]))

Time complexity: O(L + m · 2^m), where L is the total input length and m is the number of internally valid words | Space complexity: O(m)

This was where the clock started to matter. I first tracked the built string directly. That missed collisions between separate words. Several minutes went into resetting the state. The remaining time let me finish the mask search.

Instead, I ruled out a desktop overlay. It would put the answer on the monitored computer. A basic rendering layer could hide it, but the answer would still stay on-screen. I wanted no extra exposure during the test.

Also, I used InterviewFox's dual-device mode. A keyboard shortcut captured the problem and sent the answer to my phone. The phone sat outside the platform's screenshot surface.

As a result, the missing overlap check became clear. My Codility laptop stayed on the editor.

Palo Alto Networks's Proctoring Policy for Codility

First, I separated Codility's platform capability from Palo Alto Networks's invite. Codility Proctoring is configured per Screen test. It is disabled by default. Your invitation determines which signals apply.

Codility Controls Are Configurable Per Test

Additionally, employers select signals before inviting candidates. For example, Codility documents copy-paste into the IDE, tab switching, task-description copy attempts, unusually short completion, typing-pattern analysis, webcam snapshots, and optional screen, webcam, or microphone recording.

Specifically, for paste behavior, Codility's copy-and-paste tracking explains Timeline events and the questions that go to human review. I kept that event separate from a final cheating decision.

I also treated tab behavior separately. Codility's tab-switch event model covers the logged event. By contrast, a tab event and screen footage are different exposure paths.

In addition, Codility's integrity feature summary lists behavior events and other review signals. In other words, it separates platform capability from employer settings.

Device Integrity Checks the Assessment Computer

Meanwhile, when enabled, Device Integrity requires the Codility App on macOS or Windows. Also, the app checks the assessment computer for known hidden tools. However, it does not record the screen. Therefore, the employer controls whether this feature runs.

Similarly, Codility's broader integrity model groups device checks, behavior events, post-submit analysis, and human review into separate layers. Thus, this keeps a browser-only assumption from becoming a claim about every PANW invite.

The Invite Defines PANW's Active Signals

Therefore, the PANW invitation is the control point for webcam snapshots, screen recording, typing analysis, tab monitoring, and Device Integrity. Specifically, read those requests before starting.

For example, if the invite asks for camera access, Codility's webcam capture boundaries explain the platform path. Otherwise, if it asks for screen sharing, the screen-recording path shows the selected capture surface.

Finally, I used the setup flow as my final check. Still, a missing camera request does not rule out every behavioral event. A platform capability does not mean PANW selected it.

Palo Alto Networks Codility Test Format

Overall, two dated 2025 reports give the clearest process sequence. The invitation gives the current test settings. I keep those sources separate below.

2025 Reports Put Two OAs Before Recruiting

First, Codility and HireVue came before a recruiter screen in two dated 2025 Santa Clara new-grad cases. Afterward, three technical onsite rounds followed. In addition, they included behavioral components. For example, one positive outcome covered two weeks for the whole process. However, it was not a Codility-specific response wait.

Use the Invite for 2026 Timing and Count

For example, a May 2025 PANW OA report describes DSA multiple-choice questions followed by two basic coding problems in a timed test. In short, it gives useful process context. The two Codility-linked shapes in this guide serve as historical practice.

Therefore, for 2026 planning, record the duration, language, editor, completion window, link expiry, and task count shown in the invitation. I left a blocked snippet about hidden tests and three rounds out of the guide.

How Palo Alto Networks's Codility Scoring Works

Overall, correctness, performance, and integrity answer different questions. Also, Codility reports correctness and performance separately. Therefore, PANW's hiring team makes the final decision.

Correctness and Performance Are Separate Axes

I used Codility's candidate-report scoring guide to separate correctness from performance. For example, correctness covers moderate inputs and corner cases. Meanwhile, performance measures scale on larger inputs.

Passing all assessed cases gives the maximum correctness result for that dimension. A solution can pass visible cases and still need faster growth. Test both axes.

PANW Sets Its Own Hiring Cutoff

Treat the cutoff as employer-specific. A full visible sample pass shows correctness on those samples. Still, it does not predict the hiring decision.

What Candidates May See After Submission

Employer reports can include Summary, Review, Details, and Timeline fields. However, candidate feedback depends on the test setup and hiring workflow. Read the report fields available after submission.

Therefore, prepare for hidden tests. Submit code that you can defend without post-submit edits. Use the candidate report to check which fields and test results the platform exposes.

Why Candidates Fail the PANW Codility Test

In short, I saw three separate failure surfaces: focus loss, unclear process expectations, and code risks. Therefore, keep them separate when you review an assessment.

Focus Loss Exposed the Overlay

In an early-April 2026 account I reviewed, another candidate entered the assessment with a transparent AI answer overlay hidden behind the browser. A notification stole focus. The overlay surfaced above the task pane during a shortcut press. That candidate was asked for an explanation. The account says the application closed after review.

That account describes one focus-loss incident. It does not define every PANW assessment. Specifically, its trigger was notification-induced focus loss during a shortcut press. Reported consequence: application closure after review.

The overlay rendered its answer on the monitored computer. A basic OS-layer trick hid the window from view. Still, the answer stayed on-screen.

Instead, InterviewFox works differently. Its dual-device mode sends the answer to a phone. In contrast, the phone is physically separate from the assessment computer. Screenshot, screen-recording, and session monitoring stay on the laptop surface.

Hidden Tests and Slow Code Remain Structural Risks

These are two technical risks. Missed corner cases can reduce correctness. Slow code can lose performance on larger inputs. Use them as checks, not as claims about PANW's rejection policy.

A visible sample pass is only a first check. Hidden tests can probe edge cases. Submitted code may lock after the final click. I checked edge cases and runtime growth before each practice submission.

How to Prepare for the Palo Alto Networks Codility in 7 Days

I used seven flat preparation days because the practical variables live in the invitation. The plan uses two historical problem shapes, time-boxed practice, Codility's scoring dimensions, and the assessment's integrity controls.

Before the OA, I sent the fair-index and unique-character patterns to InterviewFox Prep Agent through WhatsApp. I included my target role and resume context. It returned a personalized drill plan. The same preparation context could continue into the live interview assistant.

Days 1-2: Fair-Index and Unique-Character Drills

The only readable PANW/Codility-linked problem shapes were fair-index array sums and maximum-length unique-character concatenation. I spent the first two days on those shapes because they gave me a more direct target than broad tag grinding.

For practice, I solved one prefix or suffix-sum split problem and one unique-character string-construction problem inside a single 45-minute block. Before coding, I wrote the invariant and the edge cases, then checked whether each state variable had a clear reason to exist.

My success check was strict: both solutions had to pass self-written edge cases. I had to explain why the running sums or character mask were sufficient without looking at a solution.

I skipped a full system-design or CN/OS curriculum. Those subjects came from later-round or feedback context. I left them outside this short OA plan.

Days 3-5: Correctness and Performance Under Hidden-Test Pressure

I used the time-bound OA detail and Codility's two scoring axes. Each practice run checked the answer and its growth rate.

I ran three timed array or string problems. Before coding, I wrote the expected complexity. Before submitting, I checked empty inputs, negative values, boundary positions, duplicate characters, and a large-input scenario.

My success check was practical. I wrote down edge cases. The complexity bound had to hold. I removed unscaled paths for the chosen input size. A clean sample output was only the first check.

Days 6-7: Single-Device Invite and Submission Rehearsal

The invite sets the active monitoring rules. I used the focus-loss account to set a strict final rehearsal boundary.

I reread the invitation and recorded the task count, duration, language, editor, permitted resources, and monitoring disclosures. The rehearsal used one assessment device. I used no overlays or secondary windows. I kept a submission buffer.

My final check was practical. Every invitation field went into my notes. The practice submission finished before the timeout. I avoided focus loss, paste, task-copy, and unauthorized-tool events.

What Happens After You Submit the OA

I treated the reported 2025 sequence as a downstream map, not a 2026 response-time promise. The chart below shows the clearest path after the two assessments. The OA wait belongs to the recruiting team.

Two OAs Preceded Recruiting in 2025 Reports

As noted above, Codility and HireVue came before the recruiter screen and later rounds in the two dated 2025 cases. One August 1, 2025 no-offer report covers the whole interview process. It does not describe a Codility failure. The two-week figure covers the full process, not the OA response.

The OA Wait and Reuse Rules Are Employer-Specific

Recruiter timing, retakes, cooldowns, reusable scores, candidate scores, and stage-specific reasons belong to the employer's workflow. Ask the recruiter which rule applies to your invitation.

FAQ

How many questions and how much time is the Palo Alto Networks Codility test?

A 2025 PANW OA report describes two coding problems after DSA multiple-choice questions. It gives process context. The two problem shapes in this guide are historical Codility-linked practice examples.

Is the Palo Alto Networks Codility test proctored or does it watch my screen?

Codility controls are configured per Screen test and disabled by default. The invitation and launch screen tell you whether the test requests webcam, screen, audio, or typing signals.

Can I use an AI tool or invisible app during the Palo Alto Networks Codility OA?

Desktop overlay tools place the AI answer on the assessment computer. A basic OS layer can hide the window, but the answer remains on-screen. Proctoring tools keep adding detection paths as AI use grows. Treat a same-device overlay as an exposure risk.

InterviewFox's dual-device mode sends the answer to a separate phone. The laptop stays on the exam editor. No answer appears on the monitored screen. If you use AI assistance during an OA, keep the answer surface off the assessment computer.

What score do I need to pass the Palo Alto Networks Codility test?

Treat the PANW cutoff as employer-specific. Codility separates correctness and performance. Use both metrics when reviewing practice code.

How long until I hear back after the Palo Alto Networks Codility test?

Recruiter timing is employer-specific. One 2025 new-grad process took two weeks from the first assessment through later interview stages. That figure covers the full process.