Interview blog

Coinbase CodeSignal Assessment: Format and Questions

Written March 6, 2026Updated November 3, 202613 min read
What Should You Know About Coinbase Codesignal Questions Before Your Interview

What Coinbase says about its CodeSignal test, the formats candidates report, a worked four-level practice problem in Python, and what comes after it.

The Coinbase CodeSignal test is a coding assessment that Coinbase asks engineering, product and design applicants to complete, on top of a separate 30-minute cognitive and culture assessment. Coinbase does not publish its format, so the details come from CodeSignal's documentation and from candidates. One guide describes four separate questions in 70 minutes, while a February 2025 LeetCode report describes a four-level CodeSignal problem built around a key-value store, and an August 2026 Glassdoor review describes a four-level online assessment, not named as CodeSignal, built around an in-memory cloud storage system. The time limit and question count in your own invitation are the ones that count, so read it before you plan anything. Below we cover what Coinbase says, the two formats, dated reports, and a practice problem we wrote and ran.

What Coinbase says about the assessment

The most specific official source is a March 2024 post on the Coinbase blog, "How to interview at Coinbase". It describes six stages that take about 60 days on average: application review, a recruiter screen, structured assessments, up to four one-to-one interviews, a work trial for most roles, and an offer review. Coinbase says only about 5% of applications get past the first stage.

The structured assessment is the part people tend to confuse with CodeSignal. Coinbase describes it as a test of roughly 30 minutes that measures cognitive ability, meaning logical and spatial, verbal and mathematical reasoning, along with culture alignment. CodeSignal comes on top of that, as a note in the same post explains, for product, engineering and design applicants. If your invitation mentions logic puzzles or work-style statements, that is the cognitive test, and we cover it separately in our guides to the Coinbase cognitive assessment and the Coinbase logical reasoning test.

The post also says engineers skip the presentation-style work trial and take a live coding interview instead, which we come back to in the section on what happens after the test.

Which CodeSignal format you may get

CodeSignal runs several standard tests, and the two that match the Coinbase reports are quite different. The General Coding Assessment (GCA) gives you four questions of varying difficulty and 70 minutes, all visible from the start and answerable in any order. CodeSignal scores it on correctness, speed, implementation and problem solving, and it does not allow outside IDEs.

The Industry Coding Assessment (ICA) is one project-based question with four progressive levels and a maximum of 90 minutes. Each level builds on the previous one, so CodeSignal says you have to reuse, encapsulate and refactor earlier code to keep it backward compatible. Its help article also says candidates are not necessarily expected to finish every level in that time. CodeSignal's certified tests report a score from 200 to 600, and CodeSignal allows two attempts at the ICA within a rolling 180-day window, as long as the company sends a new invitation.

Coinbase could also be sending a custom assessment built on either structure, and nothing public tells us which test is behind a given invitation. Our CodeSignal assessment guide covers the scoring, result sharing and retake rules in full, so we do not repeat them here.

What candidates report being asked

We have kept to reports that name the employer and give a date, and we treat each one as a single person's experience rather than a rule.

  • interviewing.io's Coinbase guide, first published in 2023 and last updated in October 2026, describes a 70-minute asynchronous test with four data structures and algorithms questions, the first usually a warm-up and the rest around LeetCode medium, and it gives that question count as of its original publication.
  • A LeetCode post from February 2025 by an IC4 candidate in India describes a logical reasoning test first, then a four-level CodeSignal problem: a key-value store with two keys and timestamps, similar to LeetCode's Time Based Key-Value Store.
  • A Glassdoor review from February 2025 for a software engineer role in Seattle describes an aptitude test, then a four-part CodeSignal test in which the candidate finished two parts, failed one test case in the third, and still reached the final rounds.
  • A Glassdoor review from August 2026 describes an online assessment, which the review does not name as CodeSignal, with four levels in 90 minutes and the stated expectation of finishing all four, built around an in-memory cloud storage system with per-user capacity, prefix search, merging users, and backup and restore.

The interviewing.io description matches the GCA, while the LeetCode post and the August 2026 review fit the progressive ICA structure, and the Seattle review's four parts could be either, which suggests that at least some recent invitations use layered implementation problems rather than separate puzzles. Our reading is that this suits Coinbase's stated priorities. Its September 2021 engineering post says it wants production-grade code rather than a minimal, LeetCode-style optimal solution, and a problem that keeps adding requirements rewards exactly that: clear structure, sensible state and code you can extend.

The candidate who advanced with one failing test case in the third part is one data point, not evidence of a pass mark, since Coinbase does not publish one. If that test was the ICA, it fits CodeSignal's note that ICA candidates are not necessarily expected to finish, which is a reason to bank clean, tested levels rather than rush the last one.

A worked practice problem in the reported style

The problem below is our own illustration, written to resemble the two-key store in the February 2025 report. It is not a Coinbase question, and we have no knowledge of the real test's wording or test cases. Each level adds methods, and earlier ones must keep working.

Level 1 asks for set(timestamp, key, field, value), get(key, field) for the latest value, and delete(timestamp, key, field), which returns whether anything was deleted. Level 2 adds get_all(key) for every live field and delete_key(timestamp, key). Level 3 adds get_at(key, field, timestamp) for the value at a past moment, and Level 4 adds get_all_at(key, timestamp) for a snapshot of the whole key. We assume timestamps never go backwards.

from bisect import bisect_right


class TwoKeyStore:
    """Practice problem: key -> field -> value, with a history of every write."""

    def __init__(self):
        # key -> field -> (timestamps, values); a value of None records a delete
        self._data = {}

    def _history(self, key, field):
        return self._data.get(key, {}).get(field)

    # Level 1: write, read the latest value, delete one field
    def set(self, timestamp, key, field, value):
        times, values = self._data.setdefault(key, {}).setdefault(field, ([], []))
        if times and timestamp < times[-1]:
            raise ValueError("timestamps must not go backwards")
        times.append(timestamp)
        values.append(value)

    def get(self, key, field):
        history = self._history(key, field)
        return history[1][-1] if history else None

    def delete(self, timestamp, key, field):
        if self.get(key, field) is None:
            return False
        self.set(timestamp, key, field, None)
        return True

    # Level 2: every live field of a key, and deleting the whole key
    def get_all(self, key):
        fields = self._data.get(key, {})
        return {f: vals[-1] for f, (_, vals) in sorted(fields.items()) if vals[-1] is not None}

    def delete_key(self, timestamp, key):
        live = self.get_all(key)
        for field in live:
            self.delete(timestamp, key, field)
        return bool(live)

    # Level 3: the value a field had at a past timestamp
    def get_at(self, key, field, timestamp):
        history = self._history(key, field)
        if not history:
            return None
        times, values = history
        i = bisect_right(times, timestamp)
        return values[i - 1] if i else None

    # Level 4: a snapshot of the whole key at a past timestamp
    def get_all_at(self, key, timestamp):
        snapshot = {}
        for field in sorted(self._data.get(key, {})):
            value = self.get_at(key, field, timestamp)
            if value is not None:
                snapshot[field] = value
        return snapshot


s = TwoKeyStore()
s.set(1, "alice", "BTC", "0.5")
s.set(2, "alice", "ETH", "3")
s.set(5, "alice", "BTC", "0.7")
assert s.delete(6, "alice", "ETH") is True
assert s.delete(7, "alice", "ETH") is False          # already gone
assert s.get_all("alice") == {"BTC": "0.7"}
assert s.get_at("alice", "BTC", 1) == "0.5"          # the boundary is inclusive
assert s.get_at("alice", "ETH", 5) == "3"            # deleted later, still visible here
assert s.get_all_at("alice", 2) == {"BTC": "0.5", "ETH": "3"}
assert s.get_all_at("alice", 0) == {}                # before the first write

We ran this in Python 3 with a longer set of checks than the ones shown, covering missing keys, a repeated delete, delete_key on an empty key, the timestamp guard and every level's boundaries, and all of them passed.

The decision that matters is made at Level 1, before you know what Level 3 will ask. A delete is stored as a new entry with no value, a tombstone, instead of removing the field. A first draft that used Python's del would pass Levels 1 and 2 and then force a rewrite at Level 3, because the history you need for look-back reads would already be gone. Keeping the full history in sorted order also makes the past-timestamp read a binary search, which takes O(log n) time, where n is the number of writes to that field.

Level 4 is also built from Level 3 rather than written from scratch, which is the reuse CodeSignal's ICA description asks for. The edge cases worth testing at every level are the ones in the asserts: reading before the first write, reading exactly at a write's timestamp, deleting something already deleted, and asking for a key that never existed.

How to prepare in the week before

If you have about a week, split it between platform familiarity and layered problems, and leave the last day for logistics rather than new material. CodeSignal's practice area, at app.codesignal.com/assessments/practice, shows the question types in your invitation, and companies cannot see what you do there.

  • Do one practice question in the CodeSignal editor early, so the IDE, file layout and test runner are not new to you on the day.
  • Rebuild the store above from a blank file without looking, then extend it with a TTL or a prefix filter, because adding to working code is the skill a progressive test checks.
  • Practise LeetCode's Time Based Key-Value Store and Simple Bank System, since both exercise the stateful, operation-by-operation style the reports describe.
  • Run at least one full session at the time limit in your invitation, writing your own tests before you move up a level.
  • Read your invitation's rules on proctoring and searching, because CodeSignal says the rules vary by test; for the GCA it allows searches for syntax, not for help with the logic.

What happens after the CodeSignal test

Coinbase's 2024 post says the interview stage is up to four one-to-one interviews over Google Meet, each with a focus that is shared with you in advance, and that engineering candidates take a live coding interview instead of a work trial. interviewing.io adds that if you interview with more than one Coinbase team, you may not have to repeat CodeSignal.

The live coding round is where Coinbase's 2021 advice applies most. That post, which does not mention CodeSignal, says most candidates who fail the loop fail at pair programming, that problems are designed to fill more than the time available, that the naive solution is typically good enough, and that it judges readability, naming, testing and how you take feedback as well as correctness. That is the same skill set the progressive CodeSignal problem rewards, so practising for one prepares you for the other. Our overview of the Coinbase interview process covers the later rounds.

Practising with Verve AI

CodeSignal's tests can be proctored and its rules limit outside help, so any tool belongs in your preparation, not in the assessment itself. The Verve AI Coding Copilot is useful once you have written your own solution to a practice problem like the one above. It reads the question from your screen, returns a solution, and has Edge Case and Complexity actions you can compare against your own tests and analysis. For the recruiter call and the technical questions you may be asked to talk through, you can rehearse out loud in an AI mock interview, which has a Software Engineering question bank and gives a feedback report.

FAQ

Does Coinbase use CodeSignal for software engineers?

Yes. Coinbase's March 2024 hiring post says applicants for product, engineering and design roles are also asked to complete CodeSignal, which it calls a standard assessment for technical ability. It sits alongside a separate assessment of about 30 minutes that covers cognitive ability and culture alignment. Both 2025 reports we opened describe a logical reasoning or aptitude test arriving before the coding test.

How long is the Coinbase CodeSignal test?

Coinbase does not publish a length, and reports differ. interviewing.io describes 70 minutes and four questions, which matches CodeSignal's General Coding Assessment, while a 2026 Glassdoor review describes an online assessment with four progressive levels in 90 minutes, which matches the Industry Coding Assessment, though the review does not name CodeSignal. Your invitation states the limit that applies to you.

What kind of questions does Coinbase ask on CodeSignal?

A February 2025 LeetCode report describes one stateful CodeSignal problem extended over four levels, a two-key store with timestamps, and an August 2026 Glassdoor review describes a four-level online assessment, not named as CodeSignal, built around an in-memory cloud storage system with capacity limits and backups. Earlier reports describe four separate questions starting with a warm-up. Coinbase's own guidance stresses clean, tested code over minimal optimal solutions, and the progressive format gives that room to show, though interviewing.io describes the earlier format as LeetCode-medium algorithm questions.

Do you have to finish all four levels to pass?

Coinbase does not publish a pass mark. CodeSignal says ICA candidates are not necessarily expected to finish every level, and one 2025 candidate reported reaching the final rounds after completing two of four parts and passing most tests in a third, with one test case failing. Treat that as one person's result, and aim to finish each level cleanly before starting the next.

Sources

  • Coinbase's six hiring stages, about 60 days, about 5% passing application review, the 30-minute cognitive and culture assessment, CodeSignal for product, engineering and design roles, up to four interviews on Google Meet, and live coding instead of a work trial for engineers (Coinbase blog, March 19, 2024): https://www.coinbase.com/blog/how-to-interview-at-coinbase
  • Coinbase's pair programming criteria, production-grade code over LeetCode-style optimal solutions, most failures at pair programming, problems designed to overrun, naive solutions typically good enough (Coinbase blog, September 7, 2021): https://www.coinbase.com/blog/how-coinbase-interviews-for-engineering-roles
  • General Coding Assessment: four questions, 70 minutes, any order, no outside IDEs, scoring criteria: https://support.codesignal.com/hc/en-us/articles/360040370853-What-should-I-expect-when-I-take-the-General-Coding-Assessment-GCA-and-how-is-it-structured
  • Industry Coding Assessment: one question, four progressive levels, 90 minutes, not necessarily expected to finish, refactoring for backward compatibility, 200–600 score, two attempts in 180 days with a new invitation: https://support.codesignal.com/hc/en-us/articles/19116922232983-What-are-the-Industry-Coding-Assessment-ICA-rules-and-how-do-I-interpret-my-assessment-score
  • GCA syntax-only search rule and rules varying by assessment: https://support.codesignal.com/hc/en-us/articles/360040370993-How-do-I-prepare-for-this-coding-assessment-Am-I-allowed-to-use-Google-to-help-me-research
  • CodeSignal practice area, question types matching the invitation, companies not seeing practice activity: https://support.codesignal.com/hc/en-us/articles/21025134150423-How-do-I-practice-coding-questions-on-CodeSignal
  • 70-minute, four-question test with a warm-up and LeetCode-medium questions; possibly skipping CodeSignal when interviewing with several teams (interviewing.io, first published 2023, updated October 19, 2026): https://interviewing.io/coinbase-interview-questions
  • February 2025 IC4 report: logical reasoning test, four-level two-key timestamped key-value store (LeetCode Discuss, February 12, 2025): https://leetcode.com/discuss/interview-experience/6392076
  • February 2025 Seattle report (four parts, two finished, one failing test in the third, reached final rounds) and August 2026 report (an online assessment not named as CodeSignal, four levels in 90 minutes, in-memory cloud storage system) (Glassdoor reviews dated February 17, 2025 and August 14, 2026): https://www.glassdoor.com.ar/Entrevista/Coinbase-Entrevista-E779622-RVW95078049.htm
  • LeetCode Time Based Key-Value Store, referenced by the February 2025 report: https://leetcode.com/problems/time-based-key-value-store/description/
R

Ryan

CEO of Verve AI

Related reads

Explore related blog posts

Online Assessment Test: The Main Types and How to Prepare for Each
December 13, 2024Interview blog

Online Assessment Test: The Main Types and How to Prepare for Each

Online assessment test types explained: CCAT, TestGorilla, SHL and game-based tests, with format, timing, rules and how to prepare.

Read story
Big Four Online Assessment: What Each Firm Tests and Allows
October 13, 2026Interview blog

Big Four Online Assessment: What Each Firm Tests and Allows

Big Four online assessment guide: what Deloitte, EY, PwC and KPMG publish about their tests, video interviews and rules on AI use.

Read story
Bank Online Assessments and Video Interviews: What Four US Banks Publish
October 13, 2026Interview blog

Bank Online Assessments and Video Interviews: What Four US Banks Publish

Bank online assessment guide: what JPMorgan Chase, Bank of America, Wells Fargo and Capital One publish on tests and video interviews.

Read story
McKinsey Solve: What It Measures, Format, Rules and Preparation
February 1, 2026Interview blog

McKinsey Solve: What It Measures, Format, Rules and Preparation

McKinsey Solve explained from McKinsey's own pages: what it measures, format, device requirements, the rules on AI and preparation.

Read story
Top 30 Most Common Capital One Interview Questions You Should Prepare For
March 6, 2026Interview blog

Capital One Interview Questions and How the Process Works

Capital One's hiring process by role, from application to Power Day, with the questions candidates report, what each tests and illustrative answers.

Read story
What Should You Know About Capital One Power Day Before Your Final Interview
March 3, 2026Interview blog

Capital One Power Day: Format, Rounds and How to Prepare

What happens on a Capital One Power Day, round by round for each role, with a worked mini-case and a prep plan drawn from Capital One's own advice.

Read story
What Do Hiring Managers Want From Linux+ Candidates
February 9, 2026Interview blog

What Do Hiring Managers Want From Linux+ Candidates

Discover what hiring managers look for in CompTIA Linux+ candidates, skills to highlight and how to prepare.

Read story
How Can Linux Rename Directory Skills Help You Ace Technical and Professional Interviews
March 10, 2026Interview blog

How Can Linux Rename Directory Skills Help You Ace Technical and Professional Interviews

Master Linux directory renaming commands and techniques to impress in technical and professional interviews.

Read story
30 Most Common Linux System Administrator Interview Questions You Should Prepare For
March 31, 2026Interview blog

Linux System Administrator Interview Questions: 25 Scenario-Based Answers

Linux system administrator interview questions answered like real production scenarios — with the troubleshooting logic, command choices, and judgment strong.

Read story

Walk into every interview prepared and confident

Get Started For Free

Available on Mac, Windows, browser and mobile