Ramp CodeSignal Assessment: Format and Progressive Coding Practice

Check your Ramp CodeSignal format, practice an original four-stage coding exercise with a tested Python solution, and prepare without relying on unverified passing scores.

EmmaEmmaArticle Editing & Website Operations
Nov 15, 2026RampSoftware Engineer
AI-generated editorial illustration of a developer practicing coding with four connected stages and completed tests

Cover: AI-generated editorial illustration.

Ramp uses CodeSignal for technical hiring, but “Ramp CodeSignal” does not identify one fixed test. If your invitation names the Industry Coding Assessment (ICA), prepare to extend one program through four levels within a 90-minute limit. A frontend challenge or another custom assessment calls for different preparation.

Use the assessment name to choose your preparation, then practice adding requirements while keeping earlier behavior correct. The original exercise below includes a complete Python solution, expected outputs and regression checks.

About this guide: Researched November 15, 2026, from CodeSignal documentation and public preparation pages. We did not take a Ramp assessment, and the exercise is not a leaked or official Ramp question. Its solution passed the checks described below. Edited with AI assistance by SkillCopilotAI, which sells an interview assistant; the optional product workflow here is for your own practice before the assessment.

What is the Ramp CodeSignal assessment?

CodeSignal's Ramp customer story confirms that Ramp uses technical assessments for engineering and data hiring, as well as CodeSignal for later technical interviews. It also describes a separate customer-experience assessment. Those are different hiring tasks, even though they share a platform.

Public preparation pages disagree about the coding screen. For example, InterviewFox describes a progressive build, while Linkjob's guide gives conflicting question counts and durations. Neither page establishes the configuration in your invitation.

Use the assessment name to choose your preparation:

What your invitation saysWhat to prepareWhat this guide can help with
Industry Coding Assessment / ICAOne evolving implementation, earlier behavior preserved as requirements growThe four-stage exercise and regression method below
Frontend challengeThe specified UI, browser behavior, language/framework and submission requirementsIdentifying that you need a separate UI-focused rehearsal; the Python exercise is not a frontend mock
General Coding Assessment / GCASeparate coding questions under its own published rulesStart with the general CodeSignal preparation guide, then verify the named assessment
Custom assessment, data task or another roleThe actual task types and instructions shownAvoiding an unrelated coding plan; ask your recruiter if the task name is unclear

Before starting the scored session, check the displayed duration, deadline and time zone, language choices, practice area and rules. If these differ from an article, follow the invitation and assessment instructions. CodeSignal's assessment walkthrough explains where candidates see assessment information and practice with the environment.

If your invitation names ICA

CodeSignal's official ICA rules describe one project with four progressive levels and a maximum of 90 minutes. Later levels extend earlier work, so preserving existing behavior matters. CodeSignal also says completing every level is not expected.

Practise retaining working methods and tests as you add features. If an extension breaks an earlier method, time spent repairing it comes out of your budget for the new requirement. The exercise below makes that tradeoff visible without claiming to predict Ramp's questions.

Ramp CodeSignal practice: build an expense approval queue

This is an original training problem. Its four stages are an editorial practice structure, not a reproduction of CodeSignal's level specifications or a Ramp question bank. The aim is to keep one coherent data model as operations accumulate.

Implement an in-memory ExpenseQueue. Each expense has an ID, category, positive integer amount in cents, and status. There is no database, concurrency, tax calculation or currency conversion.

Data contract

Expense IDs are nonempty strings supplied by the caller. Categories are case-sensitive strings: reject an empty or whitespace-only category, but otherwise preserve it exactly. Amounts must be positive integers; reject floats and Python booleans. A failed mutation returns False and leaves all existing records unchanged.

get(id) returns an immutable tuple (category, cents, status), or None if the ID is missing. The allowed states are pending, approved and rejected. For totals(status), callers supply one of those states or omit the argument.

StageAdd these operationsKeep these earlier guarantees
1. Store expensessubmit(id, category, cents) creates a pending expense and returns True; duplicate IDs or invalid values return False. Add get(id).A duplicate submission cannot overwrite an existing expense
2. Report totalstotals(status=None) returns (category, total_cents) pairs, descending by amount, then ascending by category for ties. Omitted status includes every record. Empty reports return [].Reading a report changes nothing; IDs remain unique
3. Decidedecide(id, approved) accepts a boolean and changes a pending expense to approved or rejected. Return False for a missing ID, a non-boolean decision or an already decided record.totals() still includes every record, including rejected ones; totals('approved') filters explicitly
4. Amendamend(id, category, cents) changes a pending record's category and amount together, returning True. Reject missing/decided IDs or invalid values.Failed edits are atomic; subsequent reports use the amended values; decision rules remain unchanged

The all-status total is a reporting definition for this exercise, not an accounting recommendation. Do not silently change it when you introduce approval decisions.

Work through this sequence before coding

Start with an empty queue. Each row continues from the previous one.

CallExpected resultWhat it checks
submit('e1', 'travel', 1200)TrueCreate a pending expense
submit('e1', 'meals', 900)FalseDuplicate ID preserves the travel record
submit('e2', 'meals', 1200)TrueCreate a second category
totals()[('meals', 1200), ('travel', 1200)]Alphabetical tie-break
decide('e1', True)TrueApprove once
amend('e2', 'travel', 800)TrueMove a pending expense between categories
totals()[('travel', 2000)]Old category disappears; both records remain included
totals('approved')[('travel', 1200)]Filter by current status
amend('e1', 'meals', 100)FalseApproved records cannot be edited
decide('e2', False)TrueReject the remaining pending expense
totals('pending')[]No pending expenses remain

That category move is a useful counterexample. If you cache totals when an expense is submitted but forget to update the cache on amendment, the report will still show meals. Recomputing a report from the current records avoids that extra bookkeeping for this specification.

Python reference solution

Try each stage before reading the implementation. Keep the same object and rerun earlier tests after adding each method.

class ExpenseQueue:
    def __init__(self):
        self.rows = {}

    @staticmethod
    def _valid(category, cents):
        return isinstance(category, str) and bool(category.strip()) and type(cents) is int and cents > 0

    def submit(self, expense_id, category, cents):
        if expense_id in self.rows or not self._valid(category, cents):
            return False
        self.rows[expense_id] = (category, cents, "pending")
        return True

    def get(self, expense_id):
        return self.rows.get(expense_id)

    def totals(self, status=None):
        sums = {}
        for category, cents, state in self.rows.values():
            if status is None or state == status:
                sums[category] = sums.get(category, 0) + cents
        return sorted(sums.items(), key=lambda pair: (-pair[1], pair[0]))

    def decide(self, expense_id, approved):
        row = self.get(expense_id)
        if row is None or row[2] != "pending" or type(approved) is not bool:
            return False
        category, cents, _ = row
        self.rows[expense_id] = (category, cents, "approved" if approved else "rejected")
        return True

    def amend(self, expense_id, category, cents):
        row = self.get(expense_id)
        if row is None or row[2] != "pending" or not self._valid(category, cents):
            return False
        self.rows[expense_id] = (category, cents, "pending")
        return True

A dictionary provides expected constant-time lookup by ID. Each tuple keeps a record together, and replacing the tuple only after validation prevents a partially applied edit. get returns immutable data, so callers cannot accidentally modify a record through the returned value.

For n stored expenses and c categories in a report, submit, get, decide and amend take expected O(1) time, apart from checking category-string length. totals takes O(n + c log c) time and O(c) extra space. Stored records use O(n) space, excluding the lengths of strings. If a future stage imposes much larger reporting workloads, revisit the report strategy with those new constraints; this solution makes no constant-time reporting claim.

Run regression checks after each extension

After defining the class, run this short check locally:

q = ExpenseQueue()
assert q.get('missing') is None
assert q.submit('e1', 'travel', 1200)
assert not q.submit('e1', 'meals', 900)
assert q.submit('e2', 'meals', 1200)
assert q.totals() == [('meals', 1200), ('travel', 1200)]
assert q.decide('e1', True)
assert q.amend('e2', 'travel', 800)
assert q.totals() == [('travel', 2000)]
assert q.totals('approved') == [('travel', 1200)]
assert not q.amend('e1', 'meals', 100)
assert not q.decide('e1', False)
assert not q.submit('bad', 'travel', 0)
assert not q.amend('e2', '', 500)
assert q.get('e2') == ('travel', 800, 'pending')

Also test an empty queue, a negative amount, a float, a boolean amount, a whitespace-only category and a missing-ID amendment. Check the state after a rejected operation, not just its return value.

What we tested: The reference implementation passed three Python test groups: the worked trace, invalid/failed mutations, and 100 seeded sequences of 100 mixed operations. The sequence test compared results and records against an independent accepted-event replay model, with reports checked after every operation. These checks support this exercise's solution; they do not reproduce Ramp's hidden tests or validate an AI assistant's answers.

Use AI to review your practice code before test day

If your implementation passes simple examples but fails after several operations, a reviewer can help isolate the first incorrect state change. SkillCopilotAI's coding copilot page describes screenshot analysis and coding/debugging assistance. You can try it on your own practice code, with the exercise specification visible, before a formal assessment.

For this exercise, ask: “After changing a pending expense from meals to travel, my category totals are wrong. Find the smallest sequence that demonstrates the bug. Explain which contract it violates before suggesting a patch.” Then run the suggested sequence locally. A useful review produces a reproducible mismatch, preserves the approved-record restriction and leaves all earlier assertions passing after your fix. If the suggestion changes the specification or cannot be reproduced, do not accept it.

To try that workflow, download SkillCopilotAI for a practice-code review, install the supported Mac or Windows version, then sign in from the app to authorize the advertised 60-minute trial. Your first task is this one counterexample review, not a full mock session. The trial is time-limited, and we have not tested the assistant's output on this exercise.

Keep this workflow separate from the scored assessment. CodeSignal's certified-assessment rules restrict outside assistance and limit permitted searches to syntax references. Read the rules shown for your own assessment; this guide does not recommend capturing formal test content or using an assistant where assistance is prohibited.

For a different state-management exercise, the Airbnb CodeSignal guide includes an original file workspace with quotas and snapshots. Practice rejecting an oversized restore without changing current files; it tests a different invariant from this approval queue.

Rehearse one progressive build in 90 minutes

If your invitation confirms ICA, use a timed practice session to see where extensions start breaking earlier behavior. The allocation below is our rehearsal suggestion, not CodeSignal's scoring rubric or a Ramp hiring benchmark.

Practice minutesTaskCheck before continuing
0–10Read the exercise and write down return types, validation and orderingYou can explain what a failed mutation must preserve
10–25Implement Stage 1Duplicate and invalid submissions cannot alter records
25–40Add Stage 2Equal totals sort deterministically; empty reports work
40–60Add Stage 3A second decision fails; filtered and all-status totals differ correctly
60–80Add Stage 4Category moves and rejected edits preserve the full contract
80–90Rerun all checks and inspect the first failing sequenceEarlier behavior still works after the latest change

When stuck, reduce the failure to two or three operations. An error after an amendment may come from stale reporting state, while an error after a rejected decision may mean validation happens after mutation. Check whether the stored record is wrong or only the report is wrong before editing either method.

Before another attempt, close the reference solution and rebuild the part that failed. You are ready for a harder extension when you can explain the invariant, reproduce the original bug and pass earlier checks without copying the fix. That is a practice standard, not a prediction that Ramp will advance your application.

Scores, retakes and reported questions

What score do I need to pass Ramp's CodeSignal?

We did not find a verified, current Ramp-wide cutoff in the official sources reviewed. CodeSignal's ICA rules use a 200–600 score range. A platform score range does not establish an employer's hiring threshold. Treat online “480+ passes” or “three levels guarantees an onsite” claims as unverified unless your recruiter confirms the applicable requirement.

Can I retake the ICA immediately?

The same official ICA rules describe a maximum of two attempts in a rolling 180-day period, with a new company invitation required. That policy does not promise Ramp will send another invitation. Check the assessment named in your account and ask the recruiter about your application.

Are these the actual Ramp CodeSignal questions?

No. This guide's expense queue is original practice for maintaining behavior across extensions. Public posts can concern another role, recruiting cycle or assessment type. Use them to identify skills to train, while treating your invitation and official rules as the source for your own test conditions.

Should I only practice this kind of system?

Use it when your assessment calls for progressive implementation. If the invitation names a GCA, frontend challenge or data assessment, change your plan accordingly. For broader platform preparation, continue with the CodeSignal OA guide; for separate algorithm exercises, see the original practice problems in our Google CodeSignal guide, which are also practice rather than verified employer questions.

Prepare for your next interview

Practice interview questions, review your explanations, and explore SkillCopilotAI for interview preparation.