Ramp OA / Ramp CodeSignal 2026 Guide | SDE Online Assessment 4-Question Walkthrough

One-line summary: Ramp OA is a CodeSignal Industry-style 4-question assessment that builds one continuous "bank transaction system" — each question adds new rules on top of the previous one. The key isn't your algorithms; it's whether you can structure code cleanly.

Ramp is a U.S. B2B financial-automation unicorn (corporate cards + expense + bill pay). Its engineering culture worships reliability, so the OA mirrors real business — every question feels like building a mini banking core. This article walks through the latest 2026 questions.

1. Ramp OA Basics

Item	Detail
Platform	CodeSignal Industry Coding Framework
Duration	70 minutes
Questions	4 (incremental: Level 1 → Level 4)
Languages	Python / TypeScript / Go / Java
Pass bar	Usually 3 fully AC + Level 4 partial
Test cases	~15 hidden tests per question

Defining feature: All 4 questions share the same data model (account, transaction, refund). Later levels extend earlier code. So:

Clean Level 1 → save half the time later
Messy Level 1 → Level 4 is essentially impossible

2. Full 4-Question Walkthrough (Bank Transaction System)

Level 1: Basic Account Operations

Statement: Implement 4 APIs:

CREATE_ACCOUNT(timestamp, account_id)
DEPOSIT(timestamp, account_id, amount)
PAY(timestamp, account_id, amount)
TOP_K_ACCOUNTS_BY_OUTGOING_PAYMENTS(timestamp, k)

Idea: HashMap for balances + HashMap for cumulative spend.

class BankSystem:
    def __init__(self):
        self.balances = {}
        self.outgoing = {}

    def create(self, ts, acc):
        if acc in self.balances:
            return ""
        self.balances[acc] = 0
        self.outgoing[acc] = 0
        return "true"

    def deposit(self, ts, acc, amt):
        if acc not in self.balances:
            return ""
        self.balances[acc] += amt
        return str(self.balances[acc])

    def pay(self, ts, acc, amt):
        if acc not in self.balances or self.balances[acc] < amt:
            return ""
        self.balances[acc] -= amt
        self.outgoing[acc] += amt
        return str(self.balances[acc])

    def top_k(self, ts, k):
        ranked = sorted(self.outgoing.items(),
                        key=lambda x: (-x[1], x[0]))
        return ", ".join(f"{a}({v})" for a, v in ranked[:k])

Level 2: Transfer

New API: TRANSFER(timestamp, source_id, target_id, amount)

Note: Transfers must be atomic — if either side fails, the whole op fails.

def transfer(self, ts, src, tgt, amt):
    if src == tgt or src not in self.balances or tgt not in self.balances:
        return ""
    if self.balances[src] < amt:
        return ""
    self.balances[src] -= amt
    self.balances[tgt] += amt
    self.outgoing[src] += amt
    return str(self.balances[src])

Level 3: Scheduled Refunds (Refund Queue)

New API: SCHEDULE_REFUND(timestamp, account_id, amount, delay_ms) — refund at timestamp + delay_ms. All subsequent ops must first flush expired refunds.

import heapq

class BankSystem:
    def __init__(self):
        self.balances = {}
        self.outgoing = {}
        self.pending = []

    def _flush(self, now):
        while self.pending and self.pending[0][0] <= now:
            ts, acc, amt = heapq.heappop(self.pending)
            if acc in self.balances:
                self.balances[acc] += amt

    def schedule_refund(self, ts, acc, amt, delay):
        self._flush(ts)
        if acc not in self.balances:
            return ""
        heapq.heappush(self.pending, (ts + delay, acc, amt))
        return "true"

Critical pitfall: Every API entry must call _flush(ts) first, otherwise queries return stale data.

Level 4: Spending Limit

New API: SET_PAYMENT_LIMIT(timestamp, account_id, limit, window_ms) — total spend in the trailing window_ms cannot exceed limit.

Idea: Per-account deque of recent payments (timestamp, amount). On PAY, evict expired entries first.

from collections import deque

class BankSystem:
    def __init__(self):
        self.balances = {}
        self.outgoing = {}
        self.pending = []
        self.limits = {}
        self.recent_pay = {}

    def set_limit(self, ts, acc, limit, window):
        if acc not in self.balances:
            return ""
        self.limits[acc] = (limit, window)
        self.recent_pay.setdefault(acc, deque())
        return "true"

    def pay(self, ts, acc, amt):
        self._flush(ts)
        if acc not in self.balances:
            return ""
        if acc in self.limits:
            limit, window = self.limits[acc]
            dq = self.recent_pay[acc]
            while dq and dq[0][0] < ts - window:
                dq.popleft()
            recent_total = sum(a for _, a in dq)
            if recent_total + amt > limit:
                return ""
        if self.balances[acc] < amt:
            return ""
        self.balances[acc] -= amt
        self.outgoing[acc] += amt
        if acc in self.limits:
            self.recent_pay[acc].append((ts, amt))
        return str(self.balances[acc])

Complexity: amortized O(1) per PAY (deque).

3. Difficulty & Time Allocation

Level	Difficulty	Suggested Time	Key Technique
1	⭐	8 min	Clean HashMap + sort
2	⭐⭐	12 min	Atomic transfer
3	⭐⭐⭐	20 min	Min-heap + flush hook
4	⭐⭐⭐⭐	25 min	Deque + limit check

Time budget: keep 5 minutes for debugging. Don't aim for 4 ACs — 3 ACs + partial Level 4 = onsite.

4. Prep Strategy

Phase	Duration	Focus
Foundation	1 week	LeetCode design problems × 30 (LRU, Twitter, HashMap)
Simulation	1 week	CodeSignal Industry official Bank/Inventory templates
Sprint	3 days	Ramp-style 4-question mocks + timing

Key principles:

Don't rewrite per question: write Level 1's class to be extensible; later levels add methods only
Unify return format: failure → "", success → string number
Reserve _flush hook: from Level 1, so Level 3 plugs in seamlessly

5. FAQ — Ramp OA / Ramp CodeSignal Common Questions

Q1: What's the bar?

3 fully AC + Level 4 ≥ 50% partial. CodeSignal score 480+ out of 600 is the typical threshold.

Q2: Can I use ChatGPT?

Officially banned. Some CodeSignal versions monitor keyboard rhythm and tab switches — cheating leads to permanent ban.

Q3: Does the question pool change?

The Bank System template is stable for 6+ months, but specific API names and fields rotate. So understand the pattern, don't memorize code.

Q4: Python or TypeScript?

Python is fastest. TypeScript suits backend specialists, but it doesn't change OA ranking.

Q5: What's the post-OA pipeline?

OA pass → Recruiter Call → Phone Coding → Onsite (2 Coding + 1 SD + 1 BQ + 1 Hiring Manager).

Q6: Which LeetCode tags?

Design + HashMap + Heap. Key problems: LC 146 (LRU), LC 355 (Twitter), LC 460 (LFU), LC 1396 (Subway Stat).

6. External Resources

🚀 Need Ramp OA / VO Coaching?

If you're preparing for Ramp, Brex, Stripe, or Mercury fintech OAs / VOs, we can help with CodeSignal Industry breakdowns, design-question scaffolding, and onsite SD mocks.

👉 Add WeChat: Coding0201 — get real questions and a 1-on-1 prep plan

Contact

WeChat: Coding0201
Email: [email protected]
Telegram: @OAVOProxy