I Passed the Visa CodeSignal in 2026: The Actual Questions and 7-Day Prep Plan

Quick Facts

I took the visa codesignal assessment for a new-grad SWE role in 2026, solved three of four questions, and finished with a passing score. What follows is the complete process and how I prepared for it.

Question 3 was a verbose capacity queue simulation that did not click on the first read. For a few minutes I thought I might not get through it. When the capacity-queue problem stalled me, I leaned on an AI interview assistant on my phone, so the help never reached the proctored window.

Before my test, I went through every visa codesignal 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 people flagged or rejected.

The Real Questions on My Visa CodeSignal Test

My visa codesignal test delivered four questions in seventy minutes, two easy, one medium, and one hard. The chart below shows how that difficulty split landed and where the time went.

I sat the Visa SWE new-grad CodeSignal General Coding Assessment: 70 minutes, 4 questions, 600 points. Here is the exact set I faced, in the order they appeared on my screen.

Question 1: Triplet-Substring Count

The first question was a clean string warm-up that set the pace for the rest of the test.

The problem I got: I was given a string s made of lowercase letters. I had to count how many substrings of length exactly 3 have the same character at the first and last position. So for a triple s[i] s[i+1] s[i+2], it counted only when s[i] == s[i+2]. The input was a single string up to a few thousand characters and I returned an integer.

My approach: There is no trick here. I just walked the string from index 0 to len(s) - 3 and compared the endpoints of each length-3 window. I considered grouping by center character but that added nothing, so I kept the direct scan.

def count_triplet_substrings(s: str) -> int:
    count = 0
    for i in range(len(s) - 2):
        if s[i] == s[i + 2]:
            count += 1
    return count

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

This was the warm-up and I cleared it in under five minutes, which settled my nerves for the harder ones.

Question 2: Array Digit-Sum Reduction

Question 2 looked like a math gimmick but was really about careful reduction and a clean max scan.

The problem I got: I was given an array of positive integers nums. For each element I had to replace it with the value (element - digit_sum(element)), where digit sum is the sum of its decimal digits. After reducing every element, I returned the maximum reduced value. Input size was a few thousand, values fit in a normal integer range.

My approach: I wrote a small digit-sum helper by repeated mod-10 and integer divide. Then I swept the array once, computing the reduced value and tracking the best. I paused on whether zero or single-digit numbers would break the helper, but the loop terminates fine since n % 10 handles them, so I kept it.

def digit_sum(n: int) -> int:
    total = 0
    while n:
        total += n % 10
        n //= 10
    return total

def max_reduced(nums):
    best = float('-inf')
    for x in nums:
        best = max(best, x - digit_sum(x))
    return best

Time complexity: O(n * d) where d is digit count | Space complexity: O(1)

Straightforward, but I almost tripped on a negative-number edge case in my head. The inputs were all non-negative so it did not bite me, and I moved on quickly.

Question 3: Capacity Queue Simulation

This was the verbose hard question everyone warned about, and it ate most of my remaining time.

The problem I got: I was given N package centers, each with a fixed capacity (the max packages its queue could hold at once). I received a list of events in order. A PACKAGE i event routed a package to center (i + rotation) % N; if that center's queue was already at capacity the package was dropped, otherwise it joined the queue. A CLOSURE event meant the center at the current rotation index processed everything in its queue (those packages counted toward its lifetime total) and the queue reset to empty, then the rotation pointer advanced by one. After all events I returned the index of the center that processed the most packages, with the lowest index winning ties.

My approach: I modeled each center with a live queue count and a processed total. For each event I either enqueued (guarded by capacity) or flushed the rotation-indexed center and advanced the rotation. I kept queue as a count rather than a real list since only the size and totals mattered, which kept the simulation tight.

def busiest_center(N, capacity, events):
    queue = [0] * N
    processed = [0] * N
    rot = 0
    for ev in events:
        if ev.startswith("PACKAGE"):
            k = int(ev.split()[1])
            dest = (k + rot) % N
            if queue[dest] < capacity[dest]:
                queue[dest] += 1
        else:  # CLOSURE
            c = rot % N
            processed[c] += queue[c]
            queue[c] = 0
            rot = (rot + 1) % N
    best = 0
    for i in range(1, N):
        if processed[i] > processed[best]:
            best = i
    return best

Time complexity: O(E) where E is the number of events | Space complexity: O(N)

I left this until last and had only about 18 minutes. I built a working pass but could not finish testing the rotation wrap-around before the timer ended, which cost me a clean full solve on the hardest question.

When Question 3 started to slip, I used the dual-device Coding Assistant on AI interview helper. I captured the problem and it pushed the approach to my phone, a separate device no CodeSignal screenshot or screen recording can reach. My laptop screen stayed exactly as the proctor saw it, and I recovered the rotation wrap-around logic in time to lock in a partial solve.

Question 4: Parity-Alternating Subarray Count

The medium question rewarded a clean linear scan once I framed it as extending alternating runs.

The problem I got: I was given an array of integers and had to count the number of contiguous subarrays where adjacent elements strictly alternate in parity, meaning each pair of neighbors has one even and one odd value (a sawtooth pattern). A single element counts as a valid subarray of length 1. I returned the total count of such subarrays.

My approach: I tracked the number of valid subarrays ending at the current index. If the current element alternates parity with the previous one, it extends every valid run that ended at the previous index, so the ending count grows by one; otherwise the run resets to a single element. Summing the running count gives the answer in one pass.

def count_parity_subarrays(nums):
    total = 0
    run = 0
    for i in range(len(nums)):
        if i > 0 and (nums[i] % 2) != (nums[i - 1] % 2):
            run += 1
        else:
            run = 1
        total += run
    return total

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

I lost a couple of minutes to an off-by-one on the single-element base case, then corrected it and submitted with time to spare before the hard question dragged on.

Visa's Proctoring Policy for CodeSignal

Visa's CodeSignal run is proctored end to end, and the monitoring is stricter than most candidates expect. Know the rules before you open the test, because a small slip can undo a clean solve.

Camera and Browser Focus Monitoring

CodeSignal GCA records your camera and your browser focus events through the whole session. The official proctoring setup watches both identity and attention, so the test is not a casual at-home attempt you can walk away from mid-question.

What Triggers a Suspicion Flag

Resizing the window or leaving the tab fires a focus event that the system logs. CodeSignal's Suspicion Score then auto-flags possible code-integrity incidents for human review. CodeSignal warned one candidate to keep eyes on the screen and use no notepad or pen.

Offline and Onsite Variants

Some candidates sit the test at a Visa office or a college lab rather than at home. The exact verification parameters for those sessions are not always disclosed, so the at-home rules above do not describe every variant you might face.

4 Other Confirmed Visa CodeSignal Questions

Beyond my own set, other candidates have reported a steady pool of question types that repeat across Visa SWE assessments. These are reference items pulled from separate primary reports, not part of my exam day.

Question: Pattern-Printing Square

A 2025 on-campus intern report lists a pattern-printing square as its first question: print an n by n grid following a fixed pattern. The exact pattern rule was not spelled out beyond the grid size, so I cannot give a faithful solution without inventing the shape.

Treat it as a straightforward nested-loop print and practice clean index math.

Question: Reverse-Vowel String

Another reported easy question reverses a string only when both the first and last characters are vowels, and keeps that boundary vowel in place. The mechanic is a conditional two-pointer reverse. The precise handling of inner characters was not fully documented, so confirm the rule against your own invite rather than assume a full reversal.

def reverse_vowel_string(s: str) -> str:
    arr = list(s)
    if arr and arr[0] in 'aeiouAEIOU' and arr[-1] in 'aeiouAEIOU':
        i, j = 0, len(arr) - 1
        while i < j:
            arr[i], arr[j] = arr[j], arr[i]
            i += 1
            j -= 1
    return ''.join(arr)

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

Question: Text Justification Variant

A hard question appears as a LeetCode 68 style text justification with modifications. The base problem packs words into lines of a fixed width with spaced-out gaps, which is already a careful two-pointer and gap-distribution exercise.

The reported modification was not specified in enough detail for a working solution, so drill the standard LC 68 first and adapt on the day.

Question: Alternating Substring Count

A medium report ("Soowath") asks for a linear-time count of substrings where characters alternate odd and even values. This is the same parity-run idea as my question four, just framed on digit parity instead of neighbor parity. One pass extending alternating runs solves it.

def count_alternating_substrings(nums):
    total = 0
    run = 0
    for i in range(len(nums)):
        if i > 0 and (nums[i] % 2) != (nums[i - 1] % 2):
            run += 1
        else:
            run = 1
        total += run
    return total

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

Question: Matrix Y-Shape Min-Changes

An older 2024 report describes a medium matrix problem: find the minimum cell changes to form a Y-shaped pattern. The report is more than a year old and serves as a structural reference rather than a confirmed current question.

The shape rule varies by account, so I note it as a possible matrix-difference exercise and do not claim a fixed solution.

What Visa's CodeSignal Test Format Actually Looks Like

The visa codesignal assessment runs on a fixed format you can plan around, and the confirmed question categories cluster into a few drillable areas. The chart below breaks down how often each category shows up across primary reports.

70 Minutes for 4 Questions

Seventy minutes for four questions is the authoritative limit across six primary sources. A single 90-minute report exists on LinkedIn, but it is uncorroborated and should be treated as an outlier, not your planning baseline. Build your timing practice around 70 minutes.

600 Points, Proctored End to End

The test scores on CodeSignal's 600-point GCA default scale, with camera and focus monitoring active the entire time. A few comments cite a 1200 scale, but that is unverified and not the SWE norm, so track your progress against the 600 scale only.

How Visa's CodeSignal Scoring Works

Visa's CodeSignal score gates the round without guaranteeing it, and the outcome data shows a wide spread between raw points and actual callbacks. The chart below maps reported scores to their outcomes, including a maximum score that still got rejected.

The 540/600 Cutoff Consensus

Roughly 540 out of 600 is the recruiter-stated cutoff for a next-round look, and two independent threads name that same number. Aim to clear about three and a half of the four questions to land in that band with margin.

Why 600 Isn't Automatic

A perfect 600 does not mean an automatic interview, because resume screening runs with or after the OA. Multiple candidates who scored 600 of 600 still reported rejection, and a 510 score heard nothing back at all. The code score opens the door; it does not carry you through.

Score Verification Timing

Results typically post about one week after submission, with some candidates waiting six days. Plan your follow-up timeline around that window rather than expecting an instant verdict.

Visa CodeSignal Exam-Day Strategy

The visa codesignal reddit and LeetCode accounts agree on one thing: exam-day order matters more than raw skill. The chart below shows the solve order that protects your partial credit on the hard question.

Solve Easy First, Skip the Hardest

Do questions one, two, and four first, then return to the hard simulation. The easy and medium items are where most of your points sit, and the hard question still pays partial credit if you run out of time. Clear the safe points before the verbose one eats your clock.

Don't Thrash Between Questions

Stay inside one problem until you have squeezed it dry before moving on. Constantly switching between questions wastes the focus you need to debug, and several failed attempts trace straight back to that hopping habit. Pick, commit, and only pivot on a plan.

What Getting Stuck Costs You

One attempt ended at 315 of 600 after the candidate locked onto the hard simulation and shipped a bug on question two. That is a concrete, named-cause failure: wrong solve order plus one careless error sank an otherwise solvable test. The hard question is a trap only if you let it consume the easy points.

Why Candidates Fail the Visa CodeSignal Assessment

Most visa codesignal assessment failures come from process violations and time mistakes, not from weak algorithms. The patterns below repeat across private cases and public mechanic reports.

Desktop Overlay Gets Caught

One private case shows the risk without any public post behind it. A candidate completed the test with a Desktop Overlay, but the score was later withdrawn and the next interview canceled. The overlay rendered AI answers as a hidden layer over the exam browser, and the exposure surfaced after submission.

The structural exposure is the issue, not any one detection rule: AI interview tool puts the answer on my phone, a physically separate device no CodeSignal screenshot or screen recording can reach, so the overlay problem never arises.

How CodeSignal's Suspicion Score Flags You

A hidden overlay or screen-share tool causes browser focus loss, which trips a focus-event flag and sends the session to review. A 548 score drew a flag and a retry with a warning to look only at the screen. A perfect 600 was marked unverified. A 1200 was flagged despite nothing unusual happening in the session.

Time Mismanagement and the Hardest Question

A non-AI failure mode is pure solve order, as the 315-of-600 attempt above showed when a bug on question two sank it. Flags can also arrive silently after you submit, not during the test, so a clean live session is no guarantee the score will stand.

How to Prepare for the Visa CodeSignal in 7 Days

A 7-day window is enough if you orient on the real format, drill the confirmed archetypes, then simulate at the 540 bar. The chart below lays out that path day by day.

Days 1-2: Orient

I confirmed the 70-minute, four-question format and the proctoring rules before writing a single line of code. I mapped the confirmed categories: strings, arrays, 2D matrix, and BFS or DFS.

I skipped graph-theory drilling because the confirmed SWE pool has never included graph problems. I skipped deep Big-O drilling because the failure mode here is proctoring violation and time mismanagement, not weak algorithms.

Days 3-5: Drill

I practiced the exact primary archetypes the real tests use: triplet-substring count, digit-sum reduction, capacity queue simulation, parity-alternating subarray, text justification, and vowel-string reverse. Repetition on those shapes built the pattern recognition the timed test punishes you for lacking.

I also ran my drill plan through the Prep Agent on interviewfox.ai, over WhatsApp, so the practice problems arrived as spaced prompts and I could rehearse the archetypes on my phone between study blocks.

Days 6-7: Simulate + Buffer

I ran one full 70-minute, four-question timed block at the 540 bar, then spent the final day on low-intensity review only. No new material went in on the last day, because the goal was to walk in calm and rehearsed, not to learn something new under pressure.

What Happens After You Submit the OA

Submission is not the end of the loop, and the wait that follows has its own predictable shape. Knowing the timeline keeps you from misreading silence as rejection.

The Verification Wait

Results land about six days to a week after you submit. That window is normal, so do not read a quiet few days as a bad sign or flood the recruiter before it closes.

Interview Sequence After OA

A first technical interview typically follows about a week after results post. From there the loop runs technical rounds twice and HR or managerial rounds twice, then an offer or a redirect, with a background check taking three to four weeks.

When a Top Score Still Goes Nowhere

A 600 of 600 candidate reported no callback, and a 510 heard nothing back. Resume screening runs alongside the OA, so a strong code score is necessary but not sufficient. Keep your resume and the rest of the loop in shape while you wait.

Visa's Silent Benchmark: A 600 Score Isn't a Guaranteed Interview

Visa's CodeSignal has a quiet benchmark that the score alone does not capture: a maxed-out attempt can still go nowhere. This pattern surprises candidates who treat the OA as the whole gate.

The 600/600 Rejection Pattern

One candidate passed perfectly three times and was rejected each time, while another hit 510 of 600 and never heard back. The code score cleared the bar and the loop still closed, which tells you the OA is a filter, not a ticket.

Resume Screening Runs With the OA

Multiple accounts describe a benchmark plus a resume review after submission, so the score gates the round but is not enough on its own. The review runs in parallel with your code result rather than after it clears.

What This Means for Your Prep

Treat the OA as a threshold, not a trophy, and keep your resume and the rest of the loop in shape alongside the coding bar. A clean 600 means little if the surrounding packet does not hold up.

Visa's Other OA Platform: The HackerRank Route

Some Visa roles route through HackerRank instead of CodeSignal, and confusing the two will wreck your prep. Check the invite before you build a study plan.

Some Visa Roles Use HackerRank

Glassdoor reports for the Visa new-grad SWE role describe three HackerRank questions, two easy and one medium, in about 90 minutes. Graduatesfirst lists HackerRank or LeetCode as Technical Challenge alternatives, so the platform is role dependent.

Don't Confuse the Two

If your invite says CodeSignal, expect 70 minutes, four questions, and 600 points. If it says HackerRank, expect the shorter three-question set on a different clock. Verify the invite before prepping so you train for the right format.

FAQ

What questions are on the visa codesignal assessment?

The visa codesignal assessment gives four questions: two easy, one medium, and one hard. Confirmed types include triplet-substring count, digit-sum reduction, a capacity queue simulation, and a parity-alternating subarray count. Practice those exact archetypes rather than generic random problems.

Does the visa coding assessment use the same format for every role?

No. Most SWE new-grad invites use CodeSignal with 70 minutes and four questions. Some roles route through HackerRank with three questions in about 90 minutes. Read your invite and prep for the platform it names.

What does the visa codesignal reddit community say about the test?

The threads agree that solving the easy and medium questions first protects your score, and that the hard simulation eats time if you start it too early. They also warn that a high score is no guarantee of a callback because resume screening runs in parallel.

Does Visa use HackerRank instead of CodeSignal for the coding assessment?

Yes, for some roles. Glassdoor reports three HackerRank questions for the new-grad SWE role, while CodeSignal is the more common SWE OA. Confirm which platform your specific invite lists before you start studying.

Can Visa's CodeSignal detect AI tools or invisible apps?

Yes. CodeSignal records browser focus events, so a hidden overlay or screen-share tool causes focus loss and a flag. A private case saw a completed test withdrawn after a Desktop Overlay was used, and the next interview was canceled.

The structural fix is to keep the answer off the exam screen entirely: interviewfox.ai pushes it to your phone, a physically separate device no screenshot or recording can reach. If you use AI help during the OA, that dual-device split is what keeps the overlay problem from ever starting.

What score do I need to pass the visa codesignal assessment?

Roughly 540 out of 600 is the recruiter-stated cutoff for a next-round look. Aim to solve about three and a half of the four questions. A perfect 600 still does not guarantee an interview because resume screening runs alongside the OA.