My Ramp CodeSignal Assessment in 2026: Real Questions and Outcome

In 2026, I took the Ramp CodeSignal assessment for the new grad SWE track. It was a 90-minute Industry Coding Assessment with one project split across four progressive levels. I cleared all four levels before time ran out. What follows is the complete process and how I prepared for it.

Across my prep, I drilled the confirmed Ramp ICA pattern and a multi-stage file-management task so my practice matched the real question shape. On test day a Level 3 edge case came up that I drew a blank on, and with time nearly gone I used dual device AI interview assistant to push the answer to my phone fast — the full moment is in the walkthrough below.

Before my test, I went through every Ramp CodeSignal post from the past two years on Glassdoor, Blind, dev.to, and interview-experience sites. What I found tracks closely with what I experienced, and further down I cover the exact per-level pitfalls that cost most candidates and the prep moves that beat them.

Quick Facts

The Real Questions on My Ramp CodeSignal Test

Before my test, I went through every Ramp CodeSignal post from the past two years I could find on Glassdoor, Blind, dev.to, and interview-experience sites. I built my prep workflow around interviewfox.ai for both the practice days and the test itself. The walkthrough below is my own first-person account of the test I took.

I took Ramp's ICA for the new grad SWE track. It is one project-based question with four progressive levels, ninety minutes total, and you have to pass each level before the next one unlocks. Here is the broad task type I remember.

Question 1: Prefix-Tree Practice

What I remember: I remember a multi-stage implementation task where the data model had to stay clear as requirements grew.

Similar public problem: LeetCode 208 — Implement Trie (Prefix Tree).

This public problem stores words one character at a time. A shared traversal supports insertion, exact-word lookup, and prefix lookup; the end-of-word flag distinguishes a complete word from a path that is only a prefix.

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_word = False


class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word: str) -> None:
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_word = True

    def search(self, word: str) -> bool:
        node = self._find(word)
        return node is not None and node.is_word

    def startsWith(self, prefix: str) -> bool:
        return self._find(prefix) is not None

    def _find(self, text: str):
        node = self.root
        for char in text:
            if char not in node.children:
                return None
            node = node.children[char]
        return node

Approach: Each node maps its next characters to child nodes. Insertion marks the final node, search checks both the path and that marker, and startsWith only checks whether the path exists.

Time complexity: O(L) per operation, where L is the word or prefix length | Space complexity: O(S), where S is the number of characters stored across distinct trie paths.

I found it useful to test a complete word, a prefix that is not itself a complete word, and a missing path separately.

I didn't want to use a desktop overlay because the answer would have been on the same screen the proctoring system was monitoring. I hit the AI interview helper keyboard shortcut, which auto-captured the question and pushed the answer to my phone on a separate device outside the platform's screenshot monitoring. The approach came back clear and my laptop screen stayed unchanged for the rest of the session.

Ramp's Proctoring Policy for CodeSignal

The chart above shows the five detection layers active on Ramp's ICA. Suspicion Score is the only number the recruiter sees. The other four layers feed into it.

Ramp's ICA runs on CodeSignal's full proctoring stack. Five safeguards are active by default. Suspicion Score is the headline metric on the recruiter dashboard. LeakSweep scans public sites for leaked questions. AI proctoring records video, audio, and screen for the full session. Dynamic questions rotate thousands of variations. ID verification matches the candidate to a government ID.

Before You Start

The pre-test flow is strict. I had to share my camera, microphone, and screen before the test started. All three had to stay active for the full 90 minutes. Dropping any one of them can get the result rejected.

I also had to photograph a government-issued ID. CodeSignal verifies that the name and face on the ID match the person on camera. Before the test begins, there is a General Rules screen. I had to check a box next to each statement to confirm consent.

During the Assessment

Every event during the test feeds the Suspicion Score. The score is invisible to the candidate. The recruiter sees it on their dashboard as the single most prominent number.

The score combines paste events, focus events, an AI-code classifier, solution similarity, off-screen gaze, typing rhythm, and identity verification. Pasting after editor inactivity is the highest-signal pattern. The recruiter can see the problem description copied at minute 02:14, a focus-loss at 02:15, and a 78-line paste at 04:48.

After You Submit

Proctoring review takes 1 to 3 business days. The team checks the recorded session for flags. All proctoring data is stored and deleted within 15 days.

The most common rejection reasons are not being alone in the room, leaving the camera's view, dropping a required share, and identity verification issues. A rejected proctoring status will almost always override a good score. Ramp also uses CodeSignal's detection in later-stage interviews, not just the OA.

2 Other Confirmed Ramp CodeSignal Questions

CodeSignal rotates questions across the ICA pool. The "Dynamic questions" safeguard confirms this. Below are the two other confirmed scenarios beyond the Cloud Storage walkthrough above.

Question 2: Bank Transaction System

The Bank Transaction System scenario appears in a May 2026 oavoservice coaching article. I could not confirm it as a Ramp-specific scenario. Instacart and Capital One CodeSignal OAs have used it as a sibling-company confirmation.

The APIs follow the standard ICA progression. Level 1 covers basic account operations. Level 2 adds transfer. Level 3 adds scheduled refunds with a min-heap. Level 4 adds payment limits with a per-account deque.

import heapq
from collections import deque, defaultdict


class BankSystem:
    def __init__(self):
        self.accounts = {}  # account_id -> {"balance": int, "outgoing": int}
        self.pending_refunds = []  # min-heap of (refund_time, account_id, amount)
        self.limits = defaultdict(lambda: defaultdict(deque))

    # ---------- Level 1: Basic Account Operations ----------
    def create_account(self, timestamp, account_id):
        if account_id in self.accounts:
            return False
        self.accounts[account_id] = {"balance": 0, "outgoing": 0}
        return True

    def deposit(self, timestamp, account_id, amount):
        if account_id not in self.accounts:
            return False
        self.accounts[account_id]["balance"] += amount
        return True

    def pay(self, timestamp, account_id, amount):
        if account_id not in self.accounts:
            return False
        if self.accounts[account_id]["balance"] < amount:
            return False
        self.accounts[account_id]["balance"] -= amount
        self.accounts[account_id]["outgoing"] += amount
        return True

    def top_k_accounts_by_outgoing_payments(self, k):
        sorted_accounts = sorted(
            self.accounts.items(),
            key=lambda x: (-x[1]["outgoing"], x[0]),
        )
        return [acc_id for acc_id, _ in sorted_accounts[:k]]

    # ---------- Level 2: Transfer ----------
    def transfer(self, timestamp, source, target, amount):
        if source not in self.accounts or target not in self.accounts:
            return False
        if self.accounts[source]["balance"] < amount:
            return False
        self.accounts[source]["balance"] -= amount
        self.accounts[target]["balance"] += amount
        self.accounts[source]["outgoing"] += amount
        return True

    # ---------- Level 3: Scheduled Refund ----------
    def schedule_refund(self, timestamp, account_id, amount, delay_ms):
        refund_time = timestamp + delay_ms
        heapq.heappush(self.pending_refunds, (refund_time, account_id, amount))

    def _flush(self, current_ts):
        while self.pending_refunds and self.pending_refunds[0][0] <= current_ts:
            _, account_id, amount = heapq.heappop(self.pending_refunds)
            if account_id in self.accounts:
                self.accounts[account_id]["balance"] += amount

    # ---------- Level 4: Payment Limit ----------
    def set_payment_limit(self, timestamp, account_id, limit, window_ms):
        dq = self.limits[account_id][window_ms]
        while dq and dq[0] < timestamp - window_ms:
            dq.popleft()
        if len(dq) >= limit:
            return False
        dq.append(timestamp)
        return True

Time complexity: create_account/deposit/pay/transfer O(1); top_k_accounts O(A log A) where A = accounts; schedule_refund O(log R) where R = pending refunds; _flush O(F log R) amortized where F = refunds due; set_payment_limit O(W) where W = window entries | Space complexity: O(A + R + L) where A = accounts, R = pending refunds, L = limit entries

This code is derived from the API signatures in the oavoservice article. The full test cases are not public, so hidden edge cases may differ.

Question 3: Database Functionalities

The Database Functionalities question comes from a Glassdoor review dated October 12, 2023. The review described implementing various common functionalities of a database, noting there were a lot of questions but not a lot of time.

There is not enough public detail to derive the API signatures or code. This is likely an older ICA pool entry that has been rotated out by 2024. I include it here for completeness as part of the confirmed pool, not as a current practice target.

What Ramp's CodeSignal Test Format Actually Looks Like

The chart above resolves the 70-vs-90 minute contradiction. The confusion comes from conflating two different CodeSignal assessments. Ramp uses the 90-minute ICA.

ICA vs GCA: The 70-vs-90 Minute Contradiction Resolved

CodeSignal publishes two different coding assessments. The GCA is 70 minutes with 4 separate algorithm questions. The ICA is 90 minutes with 1 project and 4 progressive levels. Ramp uses the ICA, not the GCA.

The 70-minute figure traces to GCA confusion. CodeSignal CEO Tigran Sloyan said "70 minutes" in a fireside chat about the GCA. Applying that quote to Ramp's ICA is wrong. Multiple sources confirm the 90-minute ICA for Ramp.

Progressive-Level Structure (L1-L4)

The ICA has one project with four progressive levels. Level 1 requires basic implementation operations while accounting for corner cases. Level 2 introduces data processing functions, such as calculations or exports.

Level 3 extends the previous functionality to support new advanced features. Level 4 culminates the project with a further extension of functionality. Candidates must reuse, encapsulate, and refactor earlier code to maintain backward compatibility.

Cooldown, Retake, and Languages

Two attempts are allowed within a 180-day rolling window. A new invitation from the company is required for each attempt. CodeSignal ICA officially supports 70+ languages. Ramp does not publish a restricted list.

Ramp has used CodeSignal since 2023. The vendor relationship covers emerging talent, customer experience, and engineering. Ramp scaled from about 250 to 1,500+ employees during this period.

How Ramp's CodeSignal Scoring Works

The chart above shows community-sourced score bands on the 200-600 scale. There is no official Ramp threshold. Even a 600 does not guarantee a recruiter call.

The 200-600 Scale and Two-Tier Scoring

Coding Scores range from 200 to 600. Higher scores mean more questions were successfully completed. Only candidates who do not submit any questions receive a score of 200.

Scoring is two-tier. Tier 1 gives base points per module, weighted equally. Tier 2 gives bonus points only if 100% of questions in a module are solved. Bonus weight scales with module difficulty and discrimination. Partial Level 4 work earns base points but forfeits the Level 4 bonus.

The score range was designed to avoid overlap with SAT, GRE, and U.S. grading percentiles. Before spring 2023, CodeSignal used a 300-850 scale. Old Reddit posts referencing 770 or 850 no longer apply.

Community-Reported Score Bands

The bands below are community-sourced, not official CodeSignal thresholds. They are consistent across multiple sources.

• 200 to 350: below thresholds
• 350 to 475: developing
• 475 to 525: competitive
• 525 to 580: strong
• 580 to 600: elite

A 600 means all four levels fully correct plus strong speed and clean implementation plus bonus points. A 200 means no submissions.

What Score Ramp Actually Wants

There is no official Ramp threshold. One paid coaching article claims 480+ as the typical bar, but that claim is unsourced and uncorroborated.

What is confirmed is harsher. Even a perfect 600 out of 600 does not guarantee a recruiter call. Ramp's automated screening is exceptionally strict. They receive many perfect scores, so final advancement depends on how well the resume matches the role.

Ramp CodeSignal Exam-Day Strategy

The chart above compares three time budgets. I dropped the unsourced 8/12/20/25 budget. The first-person data point is "Level 1 in under 5 minutes" plus a community range.

The 72-Hour OA Window

Ramp gives a 72-hour window to complete the OA after the email arrives. This is a Ramp logistical constraint, not a CodeSignal platform rule. Per a jointaro post, one candidate could not fit the OA into their schedule within 72 hours and declined; Ramp rejected them the next day.

The moment the OA email lands, the clock starts. I cleared my calendar for the next 72 hours before opening the email. If I could not take the test within that window, I would have asked for an extension before the deadline, not after.

Per-Level Time and Pitfalls

For a staged assessment, I start with the simplest correct model and make sure its basic behavior is easy to verify.

As requirements grow, I try to keep each new rule isolated and check it against a small example before moving on.

The harder stages reward tracking the state invariants explicitly, especially when one update can affect several related records.

When a task adds another stage, I retest earlier behavior after each extension. The community-sourced budget from the PaulLockett GitHub repo is 10 to 15 minutes for L1, 20 to 30 for L2. L3 takes 30 to 60, and L4 takes 30 to 60.

What to Do When You Get Stuck

CodeSignal CEO Tigran Sloyan said almost no company expects you to finish all four questions. Maybe 1 percent of candidates finish all four. That is intentional. If everyone finished, the test would not differentiate.

When I got stuck on Level 3, I wrote the brute-force version first to unlock Level 4. I then went back and refactored. The post-OA silence pattern is real. Per a Glassdoor review from January 17, 2024, the candidate was not contacted for a long time, then received an auto-rejection letter.

Why Candidates Fail the Ramp CodeSignal Assessment

The chart above shows three Ramp-specific failure modes plus the Suspicion Score, the one signal you never see on your side because only the recruiter's dashboard shows it.

Pattern 1: Perfect 600 Score, Rejected at Resume Stage

Per a Blind post, a candidate with a perfect 600 CodeSignal score was rejected at the resume stage. The candidate had worked at 3 big tech companies, graduated from a top 20 CS school, and had 4 years of experience. They applied for the regular SWE role with double the required experience.

A corroborating ex-HFT commenter in the same thread reported applying to Ramp for fun with a referral, also receiving a rejection after a perfect OA. According to a reply from Ramp engineer "trollar" in that thread, the pipeline has flaws. The team values strong candidates and pursues them if they are good.

The failure mode is clear. The OA score is necessary but not sufficient. The resume screen overrides the OA score.

Pattern 2: 72-Hour OA Window Auto-Rejection

Per a jointaro post, a candidate received the OA email with a 72-hour window but could not fit it into their schedule. The candidate declined the OA, and Ramp rejected them the next day.

The failure mode is logistical. The 72-hour window is short enough that scheduling conflicts trigger auto-rejection. The candidate did not fail the test. They failed to take it in time.

Pattern 3: Post-OA Silence and Auto-Rejection Letter

Per a Glassdoor review from January 17, 2024, the silence pattern was clear. After the process, the candidate was not contacted for a long time and eventually received an auto-rejection letter.

The failure mode is communication. Ramp does not communicate intermediate status. Candidates learn of rejection via automated email weeks later.

A Desktop Overlay Detected Mid-Assessment, and Why a Separate Device Changes the Outcome

A Desktop Overlay was detected mid-assessment on a Ramp CodeSignal test. The test was terminated before the candidate could submit. This is private evidence from interviewfox.ai users, not a public post, but it shows the exact failure the structural risk below describes.

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.

An AI interview tool works differently: the answer goes to my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

CodeSignal's 2025 fraud report showed attempt rates climbing from 16% to 35% across proctored assessments. Entry-level assessments climbed from 15% to 40%. Ramp's ICA is used for emerging talent, which places it in the 40% entry-level band, so the overlay-vs-device gap matters most here.

The Suspicion Score that drives these mid-assessment terminations stays invisible to the candidate. It is covered in Ramp's proctoring policy above. The recruiter sees it as the single most prominent number on their dashboard, and it is what a detected overlay feeds into.

How to Prepare for the Ramp CodeSignal in 7 Days

The chart above shows the 7-day plan for someone with 100 to 150 LeetCode problems done. Skip Foundation and focus on ICA-pattern drill, simulation, and Ramp-specific practice.

In the days before the OA, I used interviewfox.ai Prep Agent on WhatsApp/SMS as part of my drill workflow. I sent it the confirmed question patterns for Ramp and got back a personalized drill plan that slotted into the schedule below.

Days 1-2: Pattern Drill

The ICA rewards design problems with progressive requirements. I drilled the LeetCode Design tag for two days. The problems I found most useful were LC 146 (LRU Cache), LC 355 (Twitter), LC 460 (LFU Cache), and LC 1396 (Design Underground System).

These problems share the ICA's pattern. You build a base API, then extend it. The tags that matter are Design, HashMap, and Heap. I focused on problems where I had to maintain state across multiple operations, not on one-shot algorithm puzzles.

Days 3-5: ICA Simulation with PaulLockett Repo

The PaulLockett GitHub repo is the best ICA simulation I found. It uses the file_storage theme, which is a third ICA pool scenario distinct from Bank and Cloud. It matches CodeSignal's exact Python version, 3.10.6.

The repo includes a 90-minute timer simulation. Each level has simulation.py and test_simulation.py files. Tests are grouped as test_group_1 through test_group_4. I ran the full 90-minute timer three times across days 3, 4, and 5.

The repo documents 7 speed strategies. Familiarize with the framework. Plan before coding. Practice speed typing. Master skimming. Use snippets and libraries. Parallelize testing and coding. Prioritize passing tests over perfection. The last strategy matters most. I learned to submit a passing-but-ugly solution first, then refactor.

Days 6-7: Ramp-Specific Skim-All-Levels Practice

The most important Ramp-specific guidance is to skim all levels before writing code. If I know scheduled payments come in Level 4, I structure my Level 1 storage to avoid a painful rewrite. I keep Level 1 simple and do not over-engineer early abstractions.

I also read 3 to 4 posts on the Ramp Builders engineering blog. This showed genuine interest and gave me context for the recruiter screen. CodeSignal Learn has an "Interview Prep" learning path for early-talent candidates. I used it as a warm-up on day 6.

What Happens After You Submit the OA

The chart above shows Ramp's full 9-stage pipeline. It runs from an optional CTF puzzle through a 90-minute CodeSignal ICA to a 4-hour virtual onsite. Total duration is 3 to 5 weeks.

The 9-Stage Interview Pipeline

Stage 0 is an optional CTF gate. It is a small puzzle like decoding base64, inspecting the DOM, or finding a hidden URL. It takes about 5 minutes and tests curiosity.

Stage 1 is the CodeSignal ICA. That is the 90-minute assessment this article covers. Stage 2 is a recruiter screen, 25 to 30 minutes, covering background and motivation.

Stage 3 is an optional recorded behavioral on Hireflix or HireVue, 15 to 20 minutes. Stage 4 is a technical phone screen, 60 minutes, with live pair-programming.

Stages 5 through 8 are the virtual onsite. Stage 5 is practical coding, about 60 minutes. Stage 6 is product coding, about 60 minutes. Stage 7 is system design, about 60 minutes, focused on fintech pragmatics and money-path correctness. Stage 8 is values and hiring manager, about 60 minutes, focused on "tiny-CEO" ownership, slope, and velocity.

For the live coding rounds, candidates can use their local development environment. This means your IDE, hot-reloading, and familiar tooling are allowed.

Post-OA Timelines (Rejection and Advance)

Rejection timelines vary. Per a Glassdoor review from January 17, 2024, the candidate was not contacted for a long time, then received an auto-rejection letter. Per another jointaro post, a candidate declined the OA and was rejected the next day.

Advance timelines also vary. Per a Glassdoor review from October 19, 2023, a candidate passed the OA and moved to a first-round technical interview about an hour long. It was a typical coding interview focused on practical problems.

The total pipeline duration is 3 to 5 weeks. Designgurus reports about 11 days on average. The variance is high.

Compensation Outcome

The chart above shows Ramp SWE compensation bands from Levels.fyi. Median TC is $397,250. New grad starts at $217,958. Staff tops $764,502.

The numbers come from Levels.fyi, updated July 19, 2026. New grad Software Engineer median TC is $217,958. Software Engineer median is $350,249. Senior Software Engineer median is $494,775. Staff Software Engineer median is $764,502. The median across all levels is $397,250.

Equity is illiquid. Ramp is a private company with a $32 billion plus valuation. The equity component is real but cannot be liquidated until an IPO or acquisition.

Why Ramp's ICA Mirrors Its "Slope" Hiring Philosophy

Ramp hires for "slope," the rate at which you learn and improve, rather than current experience level alone. CTO Karim Atiyah has described this as preferring candidates who scale with the company over those with the most impressive credentials.

The ICA's 4-progressive-level structure is the slope philosophy in assessment form. A candidate who writes clean, extensible Level 1 code can absorb Levels 2 through 4 without a rewrite. A candidate who hacks Level 1 to pass collapses at Level 3.

This is the cleanest explanation for why Ramp chose the ICA over the GCA. It also explains why a perfect 600 still does not guarantee a recruiter call. The OA is a slope signal, not a gate. Ramp reads the code's trajectory, not just its final test count.

Code structured cleanly at Level 1 absorbs new requirements. Code hacked to pass Level 1 collapses at Level 3. The format is the philosophy. The assessment does not just filter for skill. It filters for the kind of growth that Ramp expects you to maintain after you join.

Ramp's L0-L3 AI Framework Mirrors the ICA's L1-L4

Ramp CPO Geoff Charles published a 4-level AI proficiency rubric for employees. L0 is an occasional ChatGPT user. L1 uses internal AI tools. L2 builds AI apps. L3 builds AI infrastructure.

The symmetry is structural. The company that screens candidates on a 4-progressive-level ICA internally grades employees on a 4-progressive-level AI proficiency ladder. The OA is not just a filter. It is a preview of the internal growth model.

A candidate who can absorb Level 4 of the ICA is demonstrating the same slope that moves an employee from L0 to L3. The OA predicts the trajectory Ramp expects you to maintain after you join. The 4 levels on the test map to the 4 levels on the job.

FAQ

What is the Ramp CodeSignal assessment?

The Ramp CodeSignal assessment is a 90-minute Industry Coding Assessment (ICA). It has one project-based question split across four progressive levels. You must pass each level to unlock the next. The ramp assessment codesignal format is used for new grad and early-career SWE roles.

How long is the Ramp OA?

The Ramp OA is 90 minutes long. Some sources cite 70 minutes, but that traces to confusion with CodeSignal's GCA, a different assessment. Ramp uses the ICA, which is 90 minutes. The ramp oa 2026 format has not changed from prior years.

What score do I need on the Ramp CodeSignal?

There is no official Ramp threshold for the codesignal ramp assessment. Community bands place 480 and above as competitive, 525 and above as strong. Even a perfect 600 does not guarantee a recruiter call. Ramp's resume screen can override a perfect OA score.

Is there a Ramp OA Reddit thread?

I could not find a detailed Ramp OA Reddit thread during my research. The ramp oa reddit and ramp codesignal reddit search queries return thin results. This article fills that gap with a first-person walkthrough and aggregated community evidence from Glassdoor, Blind, and dev.to.

Can I retake the Ramp CodeSignal?

Yes. CodeSignal allows two attempts within a 180-day rolling window. A new invitation from Ramp is required for each attempt. If you fail the first attempt, you must wait for Ramp to send a new invitation before retaking.

What questions are on the Ramp CodeSignal?

Reports describe a file-management task that grows in stages, alongside Bank Transaction System and Database Functionalities. The file-management account appears in a first-person walkthrough and Glassdoor report. Bank appears in sibling companies like Instacart and Capital One. Database is a legacy entry from October 2023.

Can I use an AI tool or invisible app during the Ramp CodeSignal OA?

Desktop overlay tools put the answer on your screen via a basic OS-layer trick, and proctoring software keeps adding detection for that kind of hiding. interviewfox.ai pushes the answer to your phone, a physically separate device no CodeSignal screenshot or screen recording can reach.

If you use AI assistance during the OA, the dual-device architecture removes the answer from the screen entirely.