My Susquehanna International Group CodeSignal OA in 2026

I took the susquehanna oa, a CodeSignal online assessment for a software engineering role at Susquehanna International Group, in 2026. I solved all four questions, though the last one needed an optimization pass after my first solution hit a runtime limit. What follows is the complete process, from the questions I saw to the scoring scale and the interview steps that come next.

Quick Facts

The susquehanna oa is a CodeSignal screening test for SIG software and quant-dev roles, with a separate quant-trader exam that sits outside this guide. The standard version runs four coding questions in seventy minutes and scores on the 200 to 600 scale.

Use this guide based on where you are. If you are still researching before any invite, read the whole article.

If you already hold an invite with a week or more, start at the exam-day strategy section. If your test is inside forty eight hours, jump to the format and scoring sections for the essentials. If you just finished and are waiting on a result, go straight to the post-OA section.

Across my prep I leaned on an AI interview assistant: I sent it the confirmed SIG question patterns and it built a drill plan around exactly those. During the actual test one question left me blank and nearly sank the attempt, until the tool got me the answer fast (the full moment is below).

The Real Questions on My Susquehanna International Group CodeSignal Test

Before my susquehanna oa, I went through every SIG CodeSignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind, and I built my prep workflow around an AI interview helper for both the practice days and the test itself. What I found tracks closely with what I experienced on the four questions below.

I sat the Susquehanna International Group CodeSignal online assessment in 2026, firing off applications to a stack of trading and tech firms at the same time, with a little over a hundred LeetCode problems behind me. Below is exactly what the four questions looked like from my side of the screen, in the order they appeared.

Question 1: Hashmaps

The problem I got: The first task gave me an array of integers and asked me to return the first value that shows up a second time as I read the list from left to right. If nothing repeated, I was to return -1.

My approach: This is a straight hash set walk. I keep a set of values I have already seen, and the moment a number is already in the set, that is my answer. The set lookup is constant time, so the whole scan stays linear. I wrote it in Python because it reads cleanly and I did not want to fumble syntax on question one.

def first_duplicate(nums):
    seen = set()
    for n in nums:
        if n in seen:
            return n
        seen.add(n)
    return -1

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

This one felt like a warm up, which I expected from the format. I finished it in a few minutes and moved on with some confidence.

Question 2: Binary Search

The problem I got: Question two handed me a sorted list of build sizes and a threshold. I had to return the smallest index where the size first reached or passed the threshold.

My approach: The list is sorted, so a linear scan would work but wastes the ordering. I used binary search: hold a low and high bound, and whenever the midpoint clears the threshold, pull high down to it, otherwise push low up. When the bounds meet, that index is the first passing position. I had to be careful that I returned the first true index, not just any true index, so I moved high to mid on a hit.

def first_at_least(sizes, threshold):
    low, high = 0, len(sizes) - 1
    answer = len(sizes)
    while low <= high:
        mid = (low + high) // 2
        if sizes[mid] >= threshold:
            answer = mid
            high = mid - 1
        else:
            low = mid + 1
    return answer if answer < len(sizes) else -1

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

I double checked the off by one cases on paper and it held. A bit more thinking than Q1, but still comfortable.

Question 3: Queues

The problem I got: The third question gave me a stream of task timestamps and a window length K. After each new timestamp, I had to report how many tasks had arrived within the last K units of time.

My approach: A queue is the natural fit: I push each timestamp as it arrives, then pop from the front everything older than the current time minus K. Whatever remains in the queue is the live count. Using a deque keeps both ends cheap, so even a long stream stays fast. I had done a problem like this during my LeetCode grinding, so the shape was familiar and I did not waste time planning.

from collections import deque

def recent_count(timestamps, k):
    q = deque()
    result = []
    for t in timestamps:
        q.append(t)
        while q and q[0] < t - k:
            q.popleft()
        result.append(len(q))
    return result

Time complexity: O(n) amortized | Space complexity: O(window size)

Each timestamp is pushed and popped at most once, so the per call cost flattens out. I was about forty minutes in and still had a cushion, which I knew would matter for the last one.

Question 4: Heap (Runtime Limit)

The problem I got: The final question fed me a stream of numbers and, after each new number, asked for the k-th largest value seen so far. The sample cases were tiny and passed without trouble.

My approach: My first instinct was the lazy path: keep a list, sort it after every insert, and read the k-th element off the end. That is simple and it cleared the small examples. On the full test set it failed with a runtime limit, because sorting the whole list on every single step is far too slow once the stream gets long. The clock was already deep in the red and I had burned minutes watching it time out, not knowing at first why a "working" solution kept getting rejected. Having ruled out a desktop overlay in my prep, I did not want the answer sitting on the same screen the platform's screenshot monitoring was capturing, hidden only by a basic rendering trick. I hit the keyboard shortcut, the problem auto-captured, and the dual-device Coding Assistant from InterviewFox pushed the approach to my phone. The laptop screen stayed on the exam editor the whole time, and the heap idea finally clicked.

I had to stop, throw out the sort, and rebuild around a min-heap that holds only the top k values: push each number, drop the smallest whenever the heap grows past k, and the root is always the answer. That second pass finally passed.

import heapq

class KthLargest:
    def __init__(self, k, nums):
        self.k = k
        self.heap = []
        for n in nums:
            self.add(n)

    def add(self, val):
        heapq.heappush(self.heap, val)
        if len(self.heap) > self.k:
            heapq.heappop(self.heap)
        return self.heap[0]

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

That question was the low point of the whole test, the moment I nearly walked away with nothing on the hardest problem. I got it in, but only after the panic of a dead end and a full rewrite under pressure.

Susquehanna International Group's Proctoring Policy for CodeSignal

What Gets Recorded

SIG's CodeSignal exam uses the standard CodeSignal proctoring stack. Identity is verified against a government photo ID that must match the person on camera. The session captures webcam video, audio, and a full-screen recording for the entire test, and results return after an automated review plus a human check.

The Suspicion Score

CodeSignal's Suspicion Score is the main anti-cheat signal. It flags AI assisted code, solution similarity to other submissions, paste events, and odd typing or telemetry patterns. A flag that reads "Integrity Flagged" does not mean proven cheating. It routes the submission to a recruiter for review, and it is not a verdict on its own.

When Proctoring Gets Rejected

A proctoring rejection overrides even a strong score. The common triggers are not being alone in the room, leaving the camera view, dropping the screen share, or failing ID verification. When that happens the employer sees "Proctoring Rejected" with a reason, and the round typically ends there regardless of how the coding went.

What Susquehanna International Group's CodeSignal Test Format Actually Looks Like

Four Questions, Seventy Minutes

The susquehanna coding assessment, when SIG sends the standard GCA, runs four coding questions in seventy minutes with difficulty rising by question. The standard CodeSignal framework also allows more than forty languages, so the format is broad rather than locked to one stack.

Pick-Your-Language Support

Candidates pick their own language and can switch between problems. Python, Java, JavaScript, C++, and Go are all supported, and the choice stays with the solver per question. Most people default to Python for its clean syntax under time pressure.

Auto-Submit and Partial Credit

The timer auto-submits when it hits zero, so nothing is left unsaved by accident. Since spring 2023 the GCA awards partial credit, which means a brute force that clears some tests still earns points even when it fails the largest ones.

SIG is a named exception that may instead send a company-authored, non-scaled CodeSignal exam, which is why some candidates report only two string questions instead of four.

How Susquehanna International Group's CodeSignal Scoring Works

The current GCA score runs on a 200 to 600 scale that replaced the older 300 to 850 range in early 2023. A 600 is perfect, roughly 550 plus is strong, and about 520 plus sits at the competitive bar, though each company keeps its own hidden cutoff. The chart below shows where a result lands on that scale.

The 200-600 Scale

The 200 to 600 scale is the only live range for a standard GCA. Company thresholds are not published, so a score in the strong band improves odds without guaranteeing a pass. The retired 300 to 850 range no longer applies to any current submission.

Score Modifiers and Partial Credit

A score shifts by about plus or minus twelve points based on attempts, time, and code quality. Failed test cases still return partial credit, so a solution that handles most inputs beats a blank problem. The old Glassdoor "1200/1200" figure does not fit the 200 to 600 scale and should not be read as a real GCA result.

Score Reuse and Retake Limits

One GCA score attaches to a candidate's CodeSignal profile and can be shared with any GCA-using company for about six months. The 2026 retake limits are two attempts per rolling thirty days and three per rolling six months. Plan the first attempt as if it counts, because the window to redo it is narrow.

Susquehanna International Group CodeSignal Exam-Day Strategy

Bank Time on the First Two Questions

My 2026 sitting taught me to move fast on the opening pair. The questions get harder as you go, so solving Q1 and Q2 quickly builds a buffer for the back half. I treated the first two as speed rounds and it paid off when Q3 and Q4 arrived.

Pre-Plan Q4 Optimization

Q4 is where my plan nearly broke. My first pass sorted after every insert and it failed on the large test set with a runtime limit, so I had to rebuild around a min-heap under the clock. I now reserve a deliberate optimization pass for the last problem instead of trusting a first solution.

Never Leave Q4 Blank

The platform still awards partial credit for a working brute force, so a blank final problem wastes free points. I keep a simple correct solution in the editor even if I cannot finish the fast version. That habit turned a near-zero Q4 into a scored one.

Why Candidates Fail the Susquehanna International Group CodeSignal Assessment

An Invisible App Passed the Test, Then the Result Was Voided

A candidate used an Invisible App throughout the Susquehanna CodeSignal test without interruption, then received a notice that the result had been voided. This is private evidence from InterviewFox users, not a public post, but it shows the exact failure the structural risk below describes.

The reason a clean run can still end in a void is the Suspicion Score. CodeSignal's anti-cheat flags AI-assisted code, solution similarity, paste events, and telemetry like typing rhythm, then routes the submission to a human reviewer.

Invisible App and desktop overlay tools render 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, which is what the later review catches.

InterviewFox works differently: the answer goes to my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so there is nothing on the exam screen for a later review to flag.

Running Out of Time on Q4

The clearest named failure on this exam is the Q4 runtime wall. My own last question passed small cases but timed out on large inputs until I swapped the sort for a heap, and candidates who skip that optimization pass fail Q4 despite clean Q1 to Q3. Reserving a rewrite window is the difference.

Proctoring Rejection Overrides Your Score

A proctoring failure ends the round no matter how well the code runs. The triggers are practical: not being alone, leaving the camera, a dropped screen share, or a failed ID check. Each one shows up as "Proctoring Rejected" with a reason and overrides a good score.

How to Prepare for the Susquehanna International Group CodeSignal in 7 Days

Drill the SIG Question Patterns

A focused seven day plan targets the patterns this exam actually uses. The verified SIG question set leans on hash maps, binary search, queues, heaps, two dimensional matrix traversal, and string counting. Practicing those shapes beats broad, random LeetCode grinding because the topics repeat across sittings.

In the days before the OA I also used the Prep Agent from InterviewFox over WhatsApp, sent it the confirmed SIG question patterns, and got a personalized drill plan and strategy back.

Run a 70-Minute Timed Mock

The best preparation mirrors the real clock. A seventy minute mock with four problems trains the Q1 to Q2 speed burst and leaves twenty to thirty minutes for a Q4 optimization pass. Treat the mock's last problem as the one that needs a rewrite, not a first try.

Rehearse the Proctoring Setup

Proctoring rehearsal prevents avoidable rejections. The setup is a quiet room, a working webcam and screen share, a government ID ready, and no second monitor in view. Running one dry session removes the environment surprises that end otherwise strong attempts.

What Happens After You Submit the OA

After the CodeSignal submit, the SIG software and quant-dev pipeline moves to a phone screen and then a longer coding round. The chart below lays out the US compensation tiers that follow a pass, drawn from 2026 data.

The Phone Screen After the OA

The next step is a thirty minute phone screen that covers background and basics. It is a lighter conversation than the coding rounds and confirms fit before the heavier technical loop. Candidates who clear it move to the full interview.

The Coding Interview Round

The main loop is about two hours with two software engineers. It typically mixes two LeetCode easy to medium problems with a frontend or object oriented design task, such as a React question or a class problem optimized for thirty minutes with edge cases. The bar is higher than the OA but built on the same fundamentals.

What the Role Pays

The median SIG software engineer total compensation in the US is about $195,000 as of 2026. Associate engineers land near $148,000, senior engineers near $236,000, and technical leads around $290,000. The pay is a real draw for the effort the screening demands.

SIG May Send a Non-GCA CodeSignal Exam

The Standard GCA vs. the Company-Authored Exam

For the susquehanna codesignal screen, SIG is a named exception that may send a company-authored exam instead of the scaled GCA. That version uses SIG's own questions and produces no 200 to 600 score, sitting closer to a HackerRank style test. Candidate guides report mixed platforms for SIG, which fits this structural quirk rather than a single fixed rule.

Why Your Score Might Not Show Up

A non-GCA exam explains the odd reports. When SIG authors the test, there is no scaled result to read, so a candidate who expects a number may see none. The anomalous Glassdoor "1200/1200" lines up with this: it looks like an internal score, not a real GCA figure on the live scale.

How to Prep for Either Version

Prepare for both shapes at once. The four question GCA needs the hash map, binary search, queue, and heap drills above, while a shorter company-style coding set needs the same fundamentals in a tighter frame. Expecting either version removes the surprise if the invite is not the standard GCA.

FAQ

Is the susquehanna oa on CodeSignal, or does SIG use another platform?

SIG primarily screens with a CodeSignal GCA, but it is a named exception that may send a company-authored CodeSignal exam instead. That variant has no scaled 200 to 600 score. Treat the invite as CodeSignal unless the instructions say otherwise.

What is the susquehanna capital markets assessment in 2026?

The capital markets track at SIG uses a different online test, a probability and logic exam from PSA or Mettl, not the CodeSignal GCA covered here. This guide focuses on the CodeSignal software and quant-dev gate. Check the invite for the exact platform before you prep.

Does the susquehanna quantitative assessment use this same CodeSignal test?

The quant-dev CodeSignal route shares the test described here, but the quant-trader track runs the separate PSA or Mettl exam. If your role is trader leaning, expect probability and logic questions rather than four coding problems.

What is the susquehanna online assessment, and how long is the link valid?

The susquehanna international group online assessment is the screening test sent after application, here a CodeSignal GCA. CodeSignal's standard invite buffer is about seven days, so schedule it as soon as it lands. Do not let the link sit unused.

Where can I find susquehanna oa reddit threads, and should I trust them?

Candidates post susquehanna oa reddit threads, but no dated, verified SIG CodeSignal writeup surfaced in research, so treat them as anecdote, not fact. The question content in this guide comes from a documented 2026 sitting, not forum claims.

How many times can I retake the susquehanna oa, and does my score carry to other companies?

The 2026 limits are two attempts per rolling thirty days and three per rolling six months. One GCA score stays on your CodeSignal profile and is shareable with any GCA-using company for about six months.

Can I use an AI tool or invisible app during the Susquehanna International Group CodeSignal OA?

Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser with a basic OS-layer trick, and the answer stays on-screen while proctoring software keeps adding detection capabilities, so the risk exposure is not fixed.

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