Airbnb CodeSignal Assessment: Format, Progressive Tasks and Practice

Identify your Airbnb CodeSignal format, compare ICA with separate coding questions, and practice a progressive file workspace with a tested Python solution.

EmmaEmmaArticle Editing & Website Operations
Nov 15, 2026AirbnbEngineering applicants
AI-generated editorial illustration of an engineer practicing file operations and snapshot restoration

Cover: AI-generated editorial illustration.

Airbnb CodeSignal preparation depends on the assessment named in your invitation. A published software-engineering candidate report describes the Industry Coding Assessment (ICA): one program extended through successive levels. A separate SDET/Automation report describes independent algorithm questions. Those accounts do not establish one format for every US role or level.

If your invite says ICA, practice changing a working system without breaking earlier behavior. Below, you can build an original file workspace through four stages, check a failure-sensitive example, and compare your implementation with a complete Python answer. If it says GCA, prioritize separate coding problems instead.

About this guide: Researched November 15, 2026, using official CodeSignal documentation and public candidate accounts. We did not take an Airbnb assessment. The exercise is our own training problem, not an official or leaked Airbnb question. Its code was executed against the checks described below. Edited with AI assistance by SkillCopilotAI, which sells an interview assistant; its optional use here is for your own preparation.

Is Airbnb CodeSignal an ICA or a GCA?

Check the assessment title before choosing a practice plan. These formats train different skills:

Invitation or task descriptionWhat it means for preparation
Industry Coding Assessment / ICACodeSignal describes one project, four progressive levels and a maximum of 90 minutes. Keep earlier functionality working while adding requirements.
General Coding Assessment / GCACodeSignal describes four separate questions available from the start, normally within 70 minutes. Practice selecting and solving independent problems. Follow any different employer-specified duration.
Custom assessment or an unclear titleConfirm the duration, task structure and permitted languages. Four questions alone do not prove it is the certified GCA.
A scheduled live coding interviewConfirm the editor and whether you will explain, debug or extend code with an interviewer. An asynchronous OA guide does not define this round.

The format descriptions come from CodeSignal's ICA rules, GCA structure and GCA rules and setup. They describe named assessments, not an Airbnb-wide hiring policy. CodeSignal also says ICA candidates are not expected to complete every level.

What do Airbnb candidate reports actually establish?

Public accountRole or experience identifiedWhat it supportsWhat remains unknown
PracHub software-engineering accountSoftware Engineer; level not establishedThat applicant names ICA and describes a task-management system growing through four levels.Country, a universal role policy and a guaranteed outcome.
Venkateshwara Doijode's SDET/Automation accountSDET / AutomationThat applicant describes four independent algorithm tasks and no advancement after a reported 461/600.Whether it was GCA, country, level and the reason for rejection. The score is not a published cutoff.
FastPrep September 2026 accountSoftware Engineer applicant reporting seven years of experienceAn OA invitation was reported.Task format, location and outcome. Years of experience alone do not establish the requisition's level.

For a US application, these are clues to check against your invitation. We did not verify an official US-wide mapping from new graduate, midlevel or senior roles to ICA versus GCA. Ask the recruiter: “Which named assessment is this, and does it use one evolving project or separate problems?”

Progressive tasks versus ordinary algorithm questions

In a separate algorithm problem, you usually choose a suitable technique and prove that one solution meets its constraints. In a progressive project, later requirements put pressure on decisions you made earlier: what gets stored, which methods share validation, and whether a rejected operation leaves the state intact.

For example, a snapshot may be valid when saved but too large for a quota imposed later. Restoring it requires both historical data and the current policy to be handled correctly. Test the resulting state after each operation, including rejected restores.

Our general CodeSignal preparation guide covers broader preparation. The exercise below concentrates on that state-management problem; it is not a full mock assessment or a prediction of Airbnb's tasks.

Original practice: a file workspace with quotas and snapshots

Build an in-memory FileWorkspace. It stores text under file names in a flat namespace. There are no directories, real disk operations, permissions or concurrent callers.

Try each stage before reading the solution. Carry your earlier tests forward whenever you add a feature.

Contract and input assumptions

Callers supply valid argument types. Names and snapshot labels are nonempty ASCII strings of at most 32 characters, containing letters, digits, periods, underscores or hyphens. Capacities are nonnegative integers. Prefixes are valid strings, including the empty string.

  • Text length means Python Unicode code points, not bytes or displayed characters. An empty file is valid; read() returns "" for it and None for a missing file.
  • Every mutating operation returns True on success or False on rejection. A rejection leaves live files, quota and saved history unchanged.
  • The workspace starts without a quota. Once set, the quota counts only text in live files. Names and snapshots do not count toward it.
  • A snapshot saves the file map, not the quota. Its label cannot be reused. Later writes must not alter it, and restores must not remove saved snapshots.
  • Restoring replaces all live files only if the saved contents fit the current quota. It leaves that quota unchanged.

This quota is a rule for the exercise, not a claim about actual memory consumption. Saved histories still consume memory.

Four stages and interfaces

StageAdd these methodsRequired behavior
1. Store textcreate(name, text), read(name), write(name, text), delete(name)Create rejects an existing name. Write and delete reject a missing name. Read returns text or None.
2. Find and copylisting(prefix=""), copy(source, target)Listing returns (name, length) pairs sorted by name. Copy rejects a missing source or existing target, including copying a file onto itself.
3. Limit live storageused(), set_limit(capacity)Used returns total live text length. Reject a limit below current usage. Create, write and copy must respect the accepted limit; exact fits succeed.
4. Preserve historysave(label), restore(label)Save rejects a duplicate label. Restore rejects an unknown label or contents exceeding the current limit. A successful restore also removes live files absent from the snapshot.

After stage 3, rerun the stage 1 and 2 tests under a generous limit. After stage 4, verify the same operations after a restore. Each stage retains the earlier contract.

A trace that exposes an unsafe restore

w = FileWorkspace()
assert w.create("notes", "abc") is True
assert w.save("v1") is True
assert w.write("notes", "") is True
assert w.create("todo", "xy") is True
assert w.set_limit(2) is True

assert w.restore("v1") is False
assert w.listing() == [("notes", 0), ("todo", 2)]

assert w.set_limit(3) is True
assert w.restore("v1") is True
assert w.listing() == [("notes", 3)]
assert w.write("notes", "z") is True
assert w.restore("v1") is True
assert w.read("notes") == "abc"

The saved version contains three code points. With a current quota of two, restoring it must fail before changing any live data. Raising the quota to three permits the restore and removes todo. The final two operations check that writing to the restored workspace does not mutate the saved version.

Original practice diagram: three saved characters cannot replace two live characters under a quota of two; a rejected restore preserves current files

Original exercise diagram. The same scenario is executable in the assertions above.

Complete Python solution

The implementation keeps a cached live-size total. Methods compute the proposed size and validate it before committing a change.

class FileWorkspace:
    def __init__(self):
        self.files = {}
        self.total = 0
        self.limit = None
        self.snapshots = {}

    def _fits(self, size):
        return self.limit is None or size <= self.limit

    def create(self, name, text):
        if name in self.files or not self._fits(self.total + len(text)):
            return False
        self.files[name] = text
        self.total += len(text)
        return True

    def read(self, name):
        return self.files.get(name)

    def write(self, name, text):
        if name not in self.files:
            return False
        size = self.total - len(self.files[name]) + len(text)
        if not self._fits(size):
            return False
        self.files[name] = text
        self.total = size
        return True

    def delete(self, name):
        if name not in self.files:
            return False
        self.total -= len(self.files.pop(name))
        return True

    def copy(self, source, target):
        if source not in self.files:
            return False
        return self.create(target, self.files[source])

    def listing(self, prefix=""):
        return sorted(
            (name, len(text))
            for name, text in self.files.items()
            if name.startswith(prefix)
        )

    def used(self):
        return self.total

    def set_limit(self, capacity):
        if self.total > capacity:
            return False
        self.limit = capacity
        return True

    def save(self, label):
        if label in self.snapshots:
            return False
        self.snapshots[label] = self.files.copy()
        return True

    def restore(self, label):
        if label not in self.snapshots:
            return False
        candidate = self.snapshots[label].copy()
        size = sum(len(text) for text in candidate.values())
        if not self._fits(size):
            return False
        self.files = candidate
        self.total = size
        return True

Why this implementation keeps the contract

Quota arithmetic: Replacing a file subtracts its old length before adding the new one. Adding the full new length to the current total would incorrectly reject a same-size rewrite at the limit. Copy delegates to create(), so duplicate-name and quota rules stay consistent.

Snapshot isolation: Python strings are immutable. Copying the dictionary is sufficient here because writes replace strings rather than mutate nested values. If file contents became mutable lists or objects, that shallow copy would no longer provide the same guarantee.

Restore atomicity: The method builds a candidate map, calculates its usage and checks the current limit before assigning it to self.files. It never restores an old limit. The saved map is copied again so later deletion or replacement of live entries cannot edit history.

With names bounded as specified, the dictionary operations and used() take expected constant time. Listing scans all n files and sorts k matches: O(n + k log k). Saving and restoring are O(n) in the size of their respective maps. Retaining snapshots can retain old contents, so history is not free storage.

Regression checks worth keeping

Run this after loading the class:

w = FileWorkspace()
assert w.create("a", "") is True
assert w.read("a") == ""
assert w.read("missing") is None
assert w.write("a", "a🙂") is True
assert w.used() == 2
assert w.set_limit(2) is True
assert w.write("a", "abc") is False
assert w.read("a") == "a🙂"
assert w.copy("a", "b") is False
assert w.listing() == [("a", 2)]
assert w.set_limit(1) is False
assert w.create("b", "") is True
assert w.save("empty-b") is True
assert w.delete("b") is True
assert w.restore("empty-b") is True
assert w.read("b") == ""

We executed eight test groups covering stage compatibility, empty text, Unicode units, exact limits, rejected mutations, snapshot independence, current-quota restoration and the published trace. They also compared 10,240 operations across 64 generated sequences with a separate list-based model that recalculates usage. These checks support this implementation under its stated contract; they do not prove compatibility with an unseen employer grader.

For a different progressive problem, our Ramp CodeSignal guide uses expense approvals. Its status transitions exercise different rules from snapshot restoration.

Prepare for the conversation after the assessment

Do not assume your next round repeats the OA. A third-party Airbnb interview guide describes coding, code review, system design and values discussions, but it does not establish the sequence for your US requisition. Ask what comes next, whether it is live, and whether you will write, review or design software.

Use this exercise to rehearse a two-minute explanation before that conversation:

  1. Name the invariant. total equals the sum of live text lengths; an accepted limit is never exceeded.
  2. Walk through one failure. The three-code-point snapshot cannot fit a current limit of two, so validation must finish before replacement.
  3. Explain the data choice. Copies isolate dictionary entries; immutable strings make a shallow copy sufficient for this contract.

Then have a partner change one requirement: “What if snapshots also count toward the quota?”

A useful answer first clarifies whether shared string contents count once or once per stored version. It then identifies which operations need new checks, including save(), and how old history will be handled when a limit is lowered. Silently charging snapshots while leaving the original tests unchanged would change the contract rather than implement it correctly.

Optional: rehearse the explanation with SkillCopilotAI

If you want follow-up help while practicing alone, SkillCopilotAI's coding interview assistant documents screenshot-based coding assistance and code explanations. After installing and signing in on Windows or Mac, show your own practice specification and implementation, ask it to challenge your restore explanation, and compare its response with the contract above.

Accept an explanation only if it preserves the current quota and explains why the snapshots remain independent. Try the changed-quota question next. A fluent response that restores an old limit or ignores history costs under the new requirement needs correction. We have not benchmarked the app's response to this exercise; this is a way for you to evaluate it during practice.

Use this workflow before the assessment. CodeSignal's published GCA rules prohibit AI assistance, including AI syntax lookups. Check the rules shown for your actual assessment rather than assuming a preparation tool is permitted in the scored session.

Questions to resolve before you start

What score passes Airbnb CodeSignal? We did not verify an official universal threshold. One applicant's score and rejection cannot establish a cutoff or its cause. Focus on the named assessment, correct behavior and the instructions for your application.

Will everyone get the same progressive tasks? The public accounts above do not establish that. Your role, requisition and invitation matter; this original practice system is not a question forecast.

What should I check besides coding? Confirm the deadline and time zone, duration, language options, environment requirements and permitted resources. Use the platform's practice area to learn the editor before the scored session. Ask the recruiter to clarify an ambiguous assessment name or the next interview's task.

Prepare for your next interview

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