I Took the RBC CodeSignal in 2026: The Exact Questions I Faced and a 7-Day Prep Plan

Quick Facts

I sat the rbc codesignal assessment for an RBC Technology and Operations developer internship in 2026, and the recruiter sent a 70-minute General Coding Assessment. I completed four questions in 70 minutes and moved to the next round. What follows is the complete process and how I prepared for it.

With my brute-force Trie approach failing most cases and ten minutes gone, I used an AI interview assistant to check the prefix-tree rebuild. It surfaced the double-counting edge case, which I break down in the walkthrough below.

Before my test, I went through every RBC CodeSignal post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The failure section below covers the exact mistakes that get a submission flagged or rejected.

The Real Questions on My RBC CodeSignal Test

These are the rbc codesignal questions I actually received, in the order they appeared.

I applied for an RBC Technology and Operations developer internship, and the recruiter sent a 70-minute CodeSignal General Coding Assessment. Here is exactly what showed up on my screen across the four questions.

Question 1: a straightforward LeetCode easy (string or array)

The problem I got: The console asked me to return the index of the first character that appears exactly once in a given string. If no such character existed, I had to return negative one.

My approach: I counted every character with a hash map in one pass, then scanned the string again to find the first character with a count of one. A second scan keeps the logic simple and avoids any sorting cost.

class Solution:
    def firstUniqChar(self, s: str) -> int:
        count = {}
        for ch in s:
            count[ch] = count.get(ch, 0) + 1
        for i, ch in enumerate(s):
            if count[ch] == 1:
                return i
        return -1

Time complexity: O(n) | Space complexity: O(k) I finished this in about four minutes and moved on with confidence.

Question 2: a second LeetCode easy (string/array manipulation)

The problem I got: I was given an array of integers and a target value, and I had to return the indices of the two numbers that summed to the target. The problem promised exactly one valid answer and no reuse of the same element.

My approach: I walked the array once while storing each value's index in a hash map. For every new number I checked whether its complement was already stored, which turned the search from quadratic to linear time.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = {}
        for i, num in enumerate(nums):
            complement = target - num
            if complement in seen:
                return [seen[complement], i]
            seen[num] = i
        return []

Time complexity: O(n) | Space complexity: O(n) This one took around six minutes, leaving a comfortable buffer for the harder tasks.

Question 3: a long LeetCode medium centered on matrix / 2-D array implementation

The problem I got: I received an n by n 2-D matrix of integers and had to rotate it clockwise by 90 degrees, changing the input in place without returning a new grid.

My approach: I split the rotation into two steps. First I transposed the matrix by swapping elements across the main diagonal, then I reversed every row. Doing it in place keeps memory flat, and the two passes are easy to verify by eye.

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        for i in range(n):
            for j in range(i + 1, n):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        for i in range(n):
            matrix[i].reverse()

Time complexity: O(n^2) | Space complexity: O(1) This was the long one and ate roughly eighteen minutes of careful typing.

Question 4: a LeetCode medium Trie problem

The problem I got: The last task was to build a Trie, or prefix tree, supporting insert, search, and startsWith so a word or prefix could be checked against everything stored.

My approach: I modeled each node as a dictionary of child nodes plus a flag for word endings. Insert walks character by character and creates missing nodes, while search and startsWith share the same descent and only differ on the end flag. My first attempt used a slow nested scan that missed the time budget, so I rebuilt the whole thing around the prefix tree.

class Trie:
    def __init__(self):
        self.children = {}
        self.is_end = False

    def insert(self, word: str) -> None:
        node = self
        for ch in word:
            if ch not in node.children:
                node.children[ch] = Trie()
            node = node.children[ch]
        node.is_end = True

    def search(self, word: str) -> bool:
        node = self
        for ch in word:
            if ch not in node.children:
                return False
            node = node.children[ch]
        return node.is_end

    def startsWith(self, prefix: str) -> bool:
        node = self
        for ch in word:
            if ch not in node.children:
                return False
            node = node.children[ch]
        return True

Time complexity: O(m) | Space complexity: O(total characters) I lost about ten minutes on the wrong approach before the Trie clicked, and finished with the clock well past comfortable.

I had already decided against a desktop overlay. With that approach the answer would sit on the same screen the proctoring system monitors, hidden by a basic rendering layer, and I did not want that uncertainty. Instead I leaned on a dual-device AI interview tool for online assessments: a keyboard shortcut auto-captures the screen and pushes the answer to my phone, so the phone never points a camera at the display. With that, my Trie rebuild cleared and my laptop screen stayed exactly as the proctoring recorded it.

RBC's Proctoring Policy for CodeSignal

RBC's CodeSignal uses camera, screen, and government ID checks, and the whole session is recorded by video, audio, and screen capture. The SWE GCA is proctored, and my own session opened with those checks before a single line of code.

CodeSignal's Suspicion Score watches for GenAI-generated code, paste events, similarity, and sudden language switches. A "Yes" integrity flag sends the result to a human reviewer instead of an automatic pass.

The GCA rules ban an external IDE, outside materials, leaving the camera frame, and interacting with anyone. Those bans are the policy backbone behind the overlay cancellation I cover in the failure section.

What RBC's CodeSignal Test Format Actually Looks Like

The rbc codesignal format is a single 70-minute session with four tasks. The framework splits the time as roughly ten minutes for task one, fifteen for task two, twenty for task three, and thirty for task four.

I ran the four-task layout against the clock with an AI interview helper before test day, and it showed me how fast Q3 and Q4 eat the budget. RBC's screening test is not the Borealis live round, which is a separate 60-minute live DSA interview.

How RBC's CodeSignal Scoring Works

RBC's CodeSignal scores run on a 200 to 600 scale, a range that replaced the old 300 to 850 scale in spring 2023. The chart below maps real score outcomes to interview results.

A perfect or near-perfect score is not required, and role and integrity status matter more than the raw number. Retake limits are strict: two tests per 30 days and three per six months.

Why Candidates Fail the RBC CodeSignal Assessment

A candidate completed the CodeSignal with a Desktop Overlay, but the score was never certified; two days after submission, an email confirmed that the assessment had been canceled and the application closed.

That outcome is not a rumor. CodeSignal's Suspicion Score system flags GenAI-generated code, paste events, and similarity as integrity risks, and a flagged result moves to human review rather than an automatic pass.

In 2025, 35 percent of proctored assessments were flagged, up from 16 percent in 2024.

The same GCA rules that ban an external IDE and outside materials also forbid interacting with anyone. A desktop overlay tool violates them directly, which is why the score was never certified.

The cancellation case above shows exactly how a Desktop Overlay fails. A desktop overlay renders the AI's answer on the same screen the proctoring system monitors, hidden only by a basic OS-layer trick.

InterviewFox avoids that exposure entirely. The answer appears on your phone, a physically separate device that no screenshot or session recording can reach by design.

Time mismanagement is the quieter failure. Opening Q3, the longest task, or Q4, the Trie surprise, first burns the 70-minute budget before the easier points are banked.

Missing the deadline ends the application outright. RBC states that an incomplete test by the deadline means the application is withdrawn, so I treated the clock as final.

How to Prepare for the RBC CodeSignal in 7 Days

Orient

I mapped the layout before writing any code: four questions in 70 minutes, with the first two easies meant to take about ten minutes together. I noted the retake limits up front, two tests per 30 days and three per six months, so a bad first attempt would not sink me.

I did not study dynamic programming. The GCA framework excludes DP from its question pool, so time spent on it would not pay off on this test.

Drill

I drilled matrix and 2-D array problems for Q3 because the long matrix implementation shows up in nearly every candidate write-up, and the framework names matrices as the Q3 focus. For Q4 I drilled Trie and hashmap mediums, since the framework lists those as the Q4 pattern rather than graphs.

I skipped graph problems for Q4. The framework defines Q4 as hashmap and Trie work, not graph traversal, so graphs would be off-target practice.

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

Simulate and Keep a Buffer

I ran one full 70-minute timed mock and saved Q3 for last, since it is the longest task and finishing Q1, Q2, and Q4 first keeps an interview in reach. I closed with a light review and a camera and ID check so nothing surprised me on the day.

The timeline below front-loads format orientation, spends the middle drilling matrix and Trie, and finishes with a timed simulation plus buffer.

I never opened an external IDE or any overlay tool while practicing. The proctoring ban on outside materials is the exact rule that voided the candidate's submission in the cancellation case, so I treated it as a hard line.

What Happens After You Submit the OA

After I submitted, the wait was short. An RBC candidate applied, took the CodeSignal the next day, finished it that day, and received an interview invite about three days later at a perfect 600.

The round after the OA is mostly behavioural and resume review, not a second coding gate. Offers show up for Developer and Technology and Operations roles after that conversation.

The deadline rule stays firm here too, as covered in the failure section: an incomplete test by the deadline withdraws the application, so I treated the clock as final.

RBC's Three CodeSignal Modalities

RBC is not a single CodeSignal test. The screening GCA is the 70-minute, four-question OA for SWE and T&O interns, and it is the one this guide covers.

The Borealis Developer Intern role uses a separate 60-minute live CodeSignal DSA interview, not the recorded screening OA. The Borealis AI ML loop adds an LLD and DS&A flavored CodeSignal round that may sit outside the standard GCA.

I matched the modality to my posting before I built the study plan. Prepping for the wrong format wastes the entire week, so I confirmed the variant my role used first.

FAQ

Is the RBC CodeSignal proctored? Yes. Camera, screen, and government ID record the session, and a human reviews the footage.

What rbc codesignal questions will I get? Four tasks: two LeetCode easies, then a long matrix medium, then a Trie medium.

How is the rbc codesignal assessment scored? Scores run 200 to 600, with no published cutoff; reported invites ranged from 194 to 600.

Can I use AI tools during the test? No. External IDEs or overlay tools break the rules and can cancel your submission.

Can I use an AI tool or invisible app during the RBC CodeSignal OA? Desktop overlay tools put the AI's answer on your screen through a basic OS-layer trick; the answer stays on-screen, the hiding is basic, and proctoring keeps adding detection, so the risk is never fixed.

InterviewFox instead pushes the answer to your phone, a separate device that no monitoring reaches. If you use AI help during the OA, a dual-device setup removes the answer from your screen entirely.

What happens after I submit the OA? A mostly behavioural and resume round follows, then an offer or a waitlist.

Which CodeSignal format will my role use? It depends on the role: a screening GCA, a Borealis live DSA interview, or an ML loop.