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 description | What it means for preparation |
|---|---|
| Industry Coding Assessment / ICA | CodeSignal describes one project, four progressive levels and a maximum of 90 minutes. Keep earlier functionality working while adding requirements. |
| General Coding Assessment / GCA | CodeSignal 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 title | Confirm the duration, task structure and permitted languages. Four questions alone do not prove it is the certified GCA. |
| A scheduled live coding interview | Confirm 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 account | Role or experience identified | What it supports | What remains unknown |
|---|---|---|---|
| PracHub software-engineering account | Software Engineer; level not established | That 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 account | SDET / Automation | That 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 account | Software Engineer applicant reporting seven years of experience | An 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 andNonefor a missing file. - Every mutating operation returns
Trueon success orFalseon 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
| Stage | Add these methods | Required behavior |
|---|---|---|
| 1. Store text | create(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 copy | listing(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 storage | used(), 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 history | save(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 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 TrueWhy 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:
- Name the invariant.
totalequals the sum of live text lengths; an accepted limit is never exceeded. - Walk through one failure. The three-code-point snapshot cannot fit a current limit of two, so validation must finish before replacement.
- 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.
Continue preparing
Editor selected
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.
Editor selected
CodeSignal OA Guide 2026: Score, Questions & Practice
Prepare for CodeSignal online assessments in 2026 with common question types, scoring expectations, coding patterns, and an ethical AI-assisted practice plan.
Editor selected
Google CodeSignal OA Questions: Reported Problems, Format and Original Practice
Prepare for a Google CodeSignal OA with clearly sourced practice themes, guidance on checking your test format, and three original exercises with tested Python solutions.
Same content type
Capital One OA: CodeSignal Questions, Scores & Prep Guide
Prepare for the Capital One OA with four original coding exercises, tested Python solutions, score and reuse guidance, and a missing-link checklist.
Prepare for your next interview
Practice interview questions, review your explanations, and explore SkillCopilotAI for interview preparation.
