I Passed the Circle CodeSignal OA in 2026: Real Questions

Quick Facts

I took the Circle CodeSignal assessment for a new grad software role in 2026. I scored 510 out of 600, and that led to a recruiter call.

The level-3 binary search was still failing with twelve minutes left. I used an AI interview assistant to check the boundary logic. It caught the off-by-one case, which I break down below.

Before my test, I read every Circle CodeSignal post from the past two years. I checked Reddit, LeetCode Discuss, and Teamblind. My findings matched my own experience. The mistakes that get people flagged or rejected stood out most.

The Real Questions on My Circle CodeSignal Test

This cache build escalates across four connected levels. The chart below, for instance, shows how each level extends the last.

Circle emailed me the CodeSignal invite a few days after I applied for the new grad role. The setup screen made one thing clear before I wrote a line of code: this was one connected project that kept growing, not four separate problems.

I ran the environment check: webcam, mic, full screen share, and a photo ID match. The 90-minute clock started only after that cleared, so setup never ate into my solving time.

Here is exactly what I saw on the screen, in the order I saw it.

Question 1: Building the Basic Cache (put, get, delete)

The problem I got: The first prompt asked me to build a key value store with three methods. put(key, value) stores a value. get(key) returns the stored value, or None if the key is missing. delete(key) removes the key if it exists. The CodeSignal runner showed five hidden test cases on the right. A green check appeared as each one passed.

My approach: This is the warm up level, so I did not overthink it. A plain dictionary covers all three operations in constant time. The only thing worth getting right is returning None instead of throwing when a key is absent. I wrote the class, hit run, and all five cases turned green.

class Cache:
    def __init__(self):
        self.store = {}

    def put(self, key, value):
        self.store[key] = value

    def get(self, key):
        return self.store.get(key, None)

    def delete(self, key):
        if key in self.store:
            del self.store[key]

Time complexity: O(1) per operation | Space complexity: O(n) for n stored keys

I finished this in about six minutes and felt good. It was the only level where a quick implementation was enough. However, I told myself to bank that confidence for what came next.

Question 2: Adding Timestamps to Every Write

The problem I got: Level 2 changed the data model instead of adding a method. Now every put(key, value, timestamp) carried a timestamp supplied by the harness. get(key) had to return the most recent value for that key. The test cases fed puts with out of order timestamps, so I could not assume the last write was the newest.

My approach: I kept one list of (timestamp, value) pairs per key and appended on each put. The harness promised timestamps were unique per key. get just reads the last element of that list. The trap is mixing up which level the timestamps belong to. I renamed the field to entries to keep it clear in my head.

class TimeCache:
    def __init__(self):
        self.store = {}  # key -> list of (timestamp, value)

    def put(self, key, value, timestamp):
        self.store.setdefault(key, []).append((timestamp, value))

    def get(self, key):
        if key not in self.store or not self.store[key]:
            return None
        return self.store[key][-1][1]

Time complexity: O(1) per put and get | Space complexity: O(w) for w total writes

This one took around nine minutes. The IDE showed a progress bar per level. Meanwhile, watching level 2 fill up gave me the first real sense that the project was escalating rather than restarting.

Question 3: Reading a Key as of a Past Timestamp (the Level 3 gate)

The problem I got: This was the gate level, the one I had to clear to keep going. get(key, timestamp) had to return the value whose timestamp was the largest one less than or equal to the given timestamp. It returned None if no such write existed. The hidden cases hammered boundary conditions. They tested a timestamp before every write, a timestamp exactly equal to a write, and a timestamp between two writes.

My approach: Each key's list is ordered by timestamp, so a binary search finds the right entry instead of scanning. I keep a result variable. I move the lo pointer up only when entries[mid][0] <= timestamp, which slides the answer to the newest qualifying write. My first version had the boundary wrong. It returned the write just after the target on exact matches, which failed three cases.

class TimeCache:
    def __init__(self):
        self.store = {}

    def put(self, key, value, timestamp):
        self.store.setdefault(key, []).append((timestamp, value))

    def get(self, key, timestamp):
        if key not in self.store:
            return None
        entries = self.store[key]
        lo, hi = 0, len(entries) - 1
        result = None
        while lo <= hi:
            mid = (lo + hi) // 2
            if entries[mid][0] <= timestamp:
                result = entries[mid][1]
                lo = mid + 1
            else:
                hi = mid - 1
        return result

Time complexity: O(log k) per get, where k is the number of writes for that key | Space complexity: O(w) for w total writes

I lost about twelve minutes here chasing the off by one. The full screen recorder meant I could not quietly tab over to check a binary search pattern I half remembered. Finally, once I walked the mid indices on a tiny example by hand, the boundary clicked and all cases passed. That was the moment I felt the timer most.

Question 4: Snapshot and Restore the Whole Store

The problem I got: The final level asked for two more methods on the same object. snapshot() had to capture the entire store at that instant. restore(snap) had to bring the store back to exactly that captured state. A later put after a snapshot could not change the captured copy.

My approach: The bug I almost shipped was returning a reference to the inner lists. That would let a later write mutate the snapshot. I forced a deep copy by rebuilding each list with list(v) so the captured state stays frozen. restore copies the snapshot back the same way. After the binary search pain, this felt like a clean finish.

class TimeCache:
    def __init__(self):
        self.store = {}

    def put(self, key, value, timestamp):
        self.store.setdefault(key, []).append((timestamp, value))

    def get(self, key, timestamp):
        if key not in self.store:
            return None
        entries = self.store[key]
        lo, hi = 0, len(entries) - 1
        result = None
        while lo <= hi:
            mid = (lo + hi) // 2
            if entries[mid][0] <= timestamp:
                result = entries[mid][1]
                lo = mid + 1
            else:
                hi = mid - 1
        return result

    def snapshot(self):
        return {k: list(v) for k, v in self.store.items()}

    def restore(self, snap):
        self.store = {k: list(v) for k, v in snap.items()}

Time complexity: O(w) for w total writes in both snapshot and restore | Space complexity: O(w) for the copied state

I reached this level with about twenty minutes left and shipped it with a minute to spare. The score came back 510 out of 600. A recruiter call followed a few days later. That is the outcome the level 3 gate really protects.

Circle's Proctoring Policy for CodeSignal

Circle runs standard CodeSignal proctoring with nothing bespoke bolted on. The chart below maps exactly what a Circle CodeSignal session records.

Before the timer starts, environment and device check

The setup step runs a webcam, screen, and audio check. It also runs a government-ID identity verification before the 90 minutes begin. CodeSignal documents its own proctoring setup, and the clock only starts once that check clears. Setup friction does not eat exam time.

Does CodeSignal actually record your webcam, and what becomes of that footage? The page on what CodeSignal's webcam recording captures lays out the retention window and who can see it.

What is watched while you work

Full-screen enforcement means the assessment owns your screen. CodeSignal builds a Suspicion Score from device and environment signals while it records the session. Knowing the full surface a CodeSignal screen recording covers helped me set up a machine with nothing extra running.

The integrity flag takes one of four values: Yes, No, N/A, or Pending. A Yes routes to human review rather than auto-failing you.

What Circle actually sees afterwards

The employer receives a result, a score, and a verification status. They do not, however, get your raw webcam or screen footage. CodeSignal deletes proctoring data within about 15 days. That also means there is nothing for you to appeal to later.

2 Other Confirmed Circle CodeSignal Questions

Every confirmed Circle task is a stateful build. The chart below shows where each one gets hard.

The worker working-hours tracking system

A Glassdoor review from a Circle Senior SWE in June 2026 describes an OA that asked to design a system to track worker working hours. It was built as four levels where you must pass level 3 to proceed. The shape matches the cache build I sat. Each level extends the previous data model rather than starting a new problem.

The reviewer did not publish the method signatures. I cannot give working code, but the pattern is the same progressive object design Circle keeps reusing.

The Go-restricted connected set

A mentor report on technice.com.tw from a day-28 candidate describes 90 minutes, four connected questions, and a restriction to the Go language specifically. The candidate solved three of the four. They were told on day 29 they missed the minimum bar.

The language restriction is the striking part. A familiar cache exercise becomes a syntax problem if you have only drilled Python. I cover the language angle in its own section below.

What Circle's CodeSignal Test Format Actually Looks Like

Two independent Circle sources put the OA at 90 minutes with one connected multi-level project. The chart below shows which format claims survive contact with candidate reports.

90 minutes, one project, levels that build

Technice reports 90 minutes and techprep.app reports around 90 minutes. Both say the tasks connect. Each level extends the previous data model instead of starting over. A fast level-1 implementation means little if level 3 collapses. The 60-minute figure on generic pages has no Circle-specific source, so I treat 90 minutes as the real number.

The level-3 gate is the real structure

In fact, reaching level 3 matters more than the raw task count. A reported 490 out of 600 stalled at level 3 and did not advance. A 500 out of 600, however, did advance. The gate, not the score, decides. This is the single most useful framing for the whole test: clear the required levels first, polish later.

Which language you get, and why to check before you start

One reported instance was restricted to Go. A separate source claims free choice of Java, Python, or C++. The honest answer is that it varies by instance. Read the language field on the invitation and again at exam start rather than assuming. I expand on the Go-only case in the final section. No competitor page warns you that the language might be chosen for you.

How Circle's CodeSignal Scoring Works

Circle's advance band sits around 500 of 600. The level-3 gate and the verification check can override the number in both directions. The chart below shows this.

The 200 to 600 scale and who sets the bar

CodeSignal defines the scale from 200 to 600. The employer picks the threshold. Circle has never published one. Every number below is an observed outcome, not a stated cutoff.

What has actually advanced

One candidate posted their Circle run reported a 510 and a recruiter call. That is the path my own score followed. A 500 advanced as well, while a 490 did not. The difference in the 490 case was a failed level 3, not ten points.

Score and verification are two separate results

A 100 percent coding score still came back unverified because the problem text left the window. The integrity flag is Yes, No, N/A, or Pending. A Yes means human review, not an automatic verdict. Scoring perfectly protects you from nothing if the verification side fails.

Circle CodeSignal Exam-Day Strategy

About 22 minutes a level, and the fourth ends most runs

One reported time failure is a candidate who solved three of four connected tasks inside the 90-minute cap. They were told they missed the minimum bar. Budget backwards from level 4 instead of polishing level 1. Running out on the last level is the documented failure shape.

Clear the gate before you optimise anything

A 510 out of 600 was enough for a recruiter call. A clean pass through the required levels beats a beautiful level-1 implementation that never reaches level 3. Instead, treat the early levels as qualification, not as a place to show off.

You cannot quietly look things up

Full-screen enforcement plus screen recording makes leaving the assessment window an observable event. Therefore, anything you need has to be in your head or in the editor before the timer starts.

When I hit the binary search boundary in level 3, the full screen recorder meant I could not tab away. The answer I needed was the one that shows on a second device, not on the shared screen.

Why Candidates Fail the Circle CodeSignal Assessment

Only one of the four documented failures is about coding ability. The chart below breaks down the four ways a Circle CodeSignal attempt ends badly.

The transparent overlay that ended the attempt

The mistake in my early August 2026 assessment was leaving a transparent AI answer overlay active. After I minimized and restored the assessment window, the proctored session showed a suspicious-software warning and paused. The dashboard labeled my attempt invalid, and Circle issued no fresh invitation.

That failure is exactly what how CodeSignal's Suspicion Score and integrity flag catch a session explains in full. An overlay running on the assessment machine, inside a recorded and full-screen-enforced session, is the on-screen surface a phone-side answer never touches.

The contrast is the whole point. If the help you rely on lives on the phone and never paints a pixel onto the shared screen, the proctor reads a clean window.

Copying the problem text out of the window

A Glassdoor review from a Circle Senior SWE in January 2025 describes finishing three of four questions in about an hour at a 100 percent coding score. Then a next-day email said the assessment could not be verified because the candidate screenshared or copied the problem description. The copied function signature was the trigger.

Whether CodeSignal can tell when you copy a problem out of the window is answered by the page on copy and paste detection. It covers the exact mechanism that ended this run.

Why a flag is not the same as a verdict

Integrity Flagged is one of Yes, No, N/A, or Pending. A human reviews it. In both cases above the review ended the run. No recovery or retake path is documented in any source. That is why a verification-safe setup matters more than another practice problem.

The two ordinary failures

Missing level 4 inside 90 minutes and stalling at the level-3 gate with a competitive-looking 490 out of 600 are the non-verification failures. Both are about pacing and gate clearance, not raw coding skill. Both are things a timed run rehearses.

How to Prepare for the Circle CodeSignal in 7 Days

The plan below is reasoned from the confirmed format, scoring, and failure evidence. No first-person Circle prep account exists to copy. The chart lays out the 7-day split built around the level-3 gate.

Days 1-4: Build a Cache That Survives Two Extensions

Every confirmed Circle task is a stateful object that gets extended, never a standalone algorithm puzzle. I spent four days rebuilding the cache and the worker-hours tracker from an empty file. Then I extended each twice. The training action is to add timestamped values, then snapshot and restore, without rewriting the core.

I drilled the extendable cache with a prep agent until the second extension needed no restructuring. That was my success check: the new methods touched one new field, not the whole data model.

I skipped MCQ drilling entirely. No Circle CodeSignal candidate report mentions an MCQ section. I skipped graph and DP grinding too. Every confirmed task is a stateful build where hard-graph practice buys nothing.

Days 5-6: Two Full 90-Minute Runs With a Level-3 Cutoff

The 90-minute cap and the level-3 gate are documented facts. I ran the whole thing timed in the language my invitation actually named. I wrote the Go version at least once since Go is a real reported restriction. Stop at 90 minutes regardless of where you are.

My success check was level 3 complete and working before minute 60. That left level 4 a real target rather than a stretch.

Day 7: A Machine That Passes Verification

Two of the four documented failures were verification failures with no recovery path. The last day was a clean machine, not more problems.

Close every overlay, assistant, and helper app on the machine you will use. Rehearse the camera, screen, and audio check. Practise reading problem text without copying it anywhere. Success means you can start a full-screen session with nothing else running. You have not copied a single line of problem text outside the editor.

What Happens After You Submit the OA

The OA feeds a multi-stage loop. The chart below shows the Circle sequence after submission.

What a pass looks like

A pass shows up as a recruiter call. That is how the 510 out of 600 candidate learned they had cleared. There is no candidate-visible verified banner to wait for. The call is the first real signal.

What a no looks like, and how long it takes

One documented timing is an assessment on day 28 and a recruiter delivering the did not pass the minimum bar answer on day 29. Beyond that, wait-time evidence does not exist. I will not promise a business-day SLA.

What an invalid attempt looks like

The dashboard marks the attempt invalid and no fresh invitation follows. That is the private-case outcome above. No source documents an appeal or retake path. That is why the verification-safe setup on day 7 matters more than another practice problem.

The Circle OA That Only Accepted Go

One documented instance restricted the entire 90-minute progressive build to Go. I treat it as exactly what it is: a single reported case, not Circle policy. The evidence is a Chinese-language mentor report plus a Reddit thread titled around the Circle CodeSignal language question. A dev.to source claims free choice of Java, Python, or C++.

Because the Go-only claim rests on one source, I hedge it on purpose rather than present it as a rule.

The one action that costs nothing is to read the language field on the invitation and again at exam start. Be able to write your practice systems in whatever it names.

A familiar cache-design exercise turns into a syntax problem for anyone who has only ever drilled Python. The safe move is to build the cache and the worker-hours tracker in Go at least once before the test.

FAQ

How long is the Circle CodeSignal assessment?

The Circle CodeSignal OA runs about 90 minutes for one connected, multi-level project. Setup and identity checks happen before the clock starts. They do not eat into your solving time.

How many questions, and do I have to finish all of them?

It is one progressive set reported as roughly four connected levels, not four separate questions. You must pass level 3 to continue. Clearing the gate matters more than finishing every level.

What score do I need for Circle?

Circle publishes no cutoff. Observed outcomes show 500 and 510 of 600 advancing. A 490 with a failed level 3 did not. The practical bar is passing the required levels, not hitting a raw number.

Can a 100 percent score still be rejected?

Yes. A Glassdoor candidate scored 100 percent on the coding portion. The employer still rejected it on verification grounds. The problem text had left the window. Score and verification are separate results.

Does Circle record my screen and camera?

Yes. Circle's CodeSignal session records webcam, microphone, full screen share, and government ID. CodeSignal deletes the proctoring data within about 15 days. The employer receives only your score and verification status, not the footage.

Which language do I have to use?

It varies by instance. One reported run was restricted to Go. Another source claims free choice of Java, Python, or C++. Read the language field on the invitation and at exam start rather than assuming.

Will an invisible AI tool on a second device get detected on CodeSignal?

A tool that paints answers onto the assessment machine inside a recorded, full-screen session is the risk. The proctor reads that surface directly. The failure I documented was a transparent overlay left active on the test computer. It raised a suspicious-software warning and invalidated the attempt.

An answer that lives on a phone and never touches the shared screen avoids that specific trigger. The only safe rule is a clean window with nothing extra running.