Airbnb is the bellwether of the short-stay / travel space, and the interview carries the same engineering culture: run + test + follow-up. Every problem you write must run, must have tests, and must absorb follow-ups. This isn't a LeetCode "submit" loop — you're expected to debug live in an IDE. This walkthrough breaks Airbnb's process into 5 stages, 3 high-frequency problems, and 1 system design, all paced to the actual loop.
Five-stage map
W0 Initial Screening: Resume → 30 min HR phone (background + expectations + base)
W1 OA HackerRank: 60-90 min, 2-3 algorithm problems (LC Medium variants)
W2 Electronic Interview: CoderPad 1-2 rounds, 45 min each
W3 Onsite VO 4-6 rounds:
├─ Coding × 2 (45 min each)
├─ System Design × 1 (60 min)
├─ Behavioral × 1 (Cultural fit + STAR)
└─ Cross-functional × 1-2 (PM / Eng Manager)
W4 Decision + offer call
End-to-end ~4-5 weeks. Airbnb moves slower than FAANG but cares more about cultural fit — there's a ~50% chance you'll meet a Director or VP for one round.
Stage 1 — HR screen (30 min)
The recruiter probes two things:
- Resume highlights — travel / e-commerce / recommender experience earns bonus points
- Expectations alignment — base / remote / start date
Templates:
- Resume tells stories: "I lifted Y by Z in project X"
- Salary: state a base + RSU range, not a single number
- Remote: be explicit on SF relocation / weekly onsite cadence
Stage 2 — OA HackerRank (60-90 min)
Usually 2-3 LC Medium problems, themes:
- String processing (housing description NLP)
- Graph traversal (city graph routing)
- Priority-queue scheduling (booking conflict resolution)
Cutoff is around 70% AC + one full AC. Airbnb OA doesn't hide monster cases, but it expects you to run a few samples in the console — HackerRank's logs are visible to reviewers.
Stage 3 — CoderPad e-interview (1-2 rounds, 45 min each)
Airbnb's signature: every problem follows write → run tests → answer follow-up. All three steps must be complete.
High-frequency problem 1 — Zigzag Matrix Print
Given an M×N matrix, print in zigzag order (not normal horizontal print).
1 2 3 → 1, 2, 3, 6, 5, 4, 7, 8, 9
4 5 6
7 8 9
def zigzag_print(matrix: list[list[int]]) -> list[int]:
out = []
for i, row in enumerate(matrix):
if i % 2 == 0:
out.extend(row)
else:
out.extend(reversed(row))
return out
Complexity: O(M·N).
Follow-ups:
- "What if
reversed()isn't allowed?" → two-pointer manual reverse - "What if it's spiral zigzag (turn at boundaries)?" → switch to direction-array simulation
- "Memory-sensitive streaming case?" → generator output
Stage 4 — Onsite VO (4-6 rounds)
Coding round 1 — Listings Subset Optimization (Hard)
Given N listings, each with
id / neighborhood / capacity. Pick listings in a given neighborhood so that total capacity ≥ groupSize, prioritizing the smallest count of listings first, then the smallest total capacity (avoid waste). Return the listing ids.
Idea: two-dimensional optimization. Greedy by capacity descending to find the minimum count, then DP / enumeration over fixed count to find minimum capacity.
def select_listings(listings: list[dict], neighborhood: str, group_size: int) -> list[int]:
pool = [l for l in listings if l["neighborhood"] == neighborhood]
pool.sort(key=lambda x: -x["capacity"])
# Step 1: minimum number of listings
cap_sum = 0
min_count = 0
for i, l in enumerate(pool):
cap_sum += l["capacity"]
if cap_sum >= group_size:
min_count = i + 1
break
if cap_sum < group_size:
return []
# Step 2: among min_count subsets, find minimum capacity
n = len(pool)
INF = float("inf")
from itertools import combinations
best_cap = INF
best_combo = None
for combo in combinations(range(n), min_count):
cap = sum(pool[i]["capacity"] for i in combo)
if cap >= group_size and cap < best_cap:
best_cap = cap
best_combo = combo
return [pool[i]["id"] for i in best_combo] if best_combo else []
Complexity: combination enum O(C(n, k)·k); can be optimized to 0/1 knapsack DP O(n · group_size).
Follow-up: "n = 1000 makes combinations explode — how do you fix it?" → 0/1 knapsack DP.
Coding round 2 — Task Scheduling with Deadline (Medium)
Tasks have
id / deadline / reward. Each takes 1 day. Maximize total reward such that each chosen task is completed by its deadline. Return execution order and total reward.
Idea: greedy + min-heap. Sort by deadline ascending; push each into heap; if heap size exceeds deadline, pop the lowest-reward task.
import heapq
def schedule_tasks(tasks: list[dict]) -> tuple[list[int], int]:
tasks_sorted = sorted(tasks, key=lambda t: t["deadline"])
heap: list[tuple[int, int]] = [] # (reward, id)
for t in tasks_sorted:
heapq.heappush(heap, (t["reward"], t["id"]))
if len(heap) > t["deadline"]:
heapq.heappop(heap) # drop lowest reward
total = sum(r for r, _ in heap)
order = [tid for _, tid in sorted(heap, key=lambda x: x[1])]
return order, total
Complexity: O(n log n).
System Design round — Airbnb Listing Search
Design Airbnb's listing search at million-scale, low latency, with filters (price, location, occupancy).
60-minute split:
05 min Clarify scope: QPS / listing scale / number of filter dimensions
05 min Data model: listing schema + index strategy
10 min Indexing: ElasticSearch inverted index + geohash
10 min Caching: Redis for hot queries / popular-city pre-warm
10 min Query path: API gateway → search service → ES → ranking → filter → result
10 min Ranking: relevance + rating + price + booking history
05 min Failure modes: ES node down, cache miss storm
05 min Follow-up: real-time inventory / partial availability
Key design points:
- Sharding: by geohash, with hot cities on dedicated shards
- Cache layer: Redis stores top 100 query × city combinations
- Consistency: listing updates flow through an event bus into ES asynchronously (eventually consistent within 30s)
- Complexity: O(log n) search on ES, O(1) cache hit
Behavioral / Cultural Fit round
Airbnb has 6 core values; the most-asked two:
- Be a host — "How do you make your team / users feel welcomed?"
- Embrace the adventure — "What's a recent step out of your comfort zone?"
Prepare a STAR template per BQ, and every story should carry a host / hospitality detail — Airbnb reviewers grade specifically for that lens.
Situation: I joined project X with low team morale
Task: As onboarding lead, I needed new hires to ramp fast
Action: Built a buddy system, weekly office hours, troubleshooting doc
Result: Ramp time dropped from 6 weeks to 3, retention up 20%
Reflection: "Being a host" isn't just welcoming — it's continually enabling
Cross-functional round
Usually with a PM / Eng Manager. The focus is storytelling and cross-discipline communication:
- "What if a PM wants to cut a feature you think is important?"
- "Tell me about a project where you disagreed with a Designer."
How to land it: switch to layman language (no DS jargon), understand the other side's motivation first, then close with data / experiments.
Three role-line variants
| Role line | Coding | System design |
|---|---|---|
| Backend SDE | DS + Hard DP | Listing Search / Booking |
| Frontend | DOM tree + state mgmt | UI rendering optimization |
| Full-stack | String + graph | API gateway design |
VO assist plug-in points for Airbnb
Airbnb's pain is the run + test + follow-up + cultural-fit quad. Standard VO assist (VO interview assist (VO live support)) cadence:
- Role-line scoping — JD + recruiter call summary classifies SDE / Frontend / Full-stack within 5 minutes
- CoderPad live drill — every problem write → run → answer follow-up three-step
- Timed mock — 45 min × 4 or 5 onsite simulation, plus a 60-min system design
- Live cueing — backstage follow-up support and SD framework prompts on the day
- Cultural-fit templates — 1 STAR story per core value, with "be a host" reinforced
FAQ
Q1: Will Airbnb founders really do interviews? A: Not the founders themselves anymore (Brian Chesky no longer interviews directly), but a Director / VP appears with ~30% probability. That round is mostly cultural fit, not technical.
Q2: Can I advance to CoderPad without full OA AC? A: One full AC + one 70% AC still has a path. Both under 50% is almost always a reject.
Q3: Is system design always Listing Search? A: ~50% chance. Common alternatives: Booking system / Pricing engine / Review aggregation. Practice all three.
Q4: Can a weak Cultural Fit round end the loop? A: Yes. Airbnb's cultural fit is a one-vote veto — even green-lit on every technical round, you can still get rejected.
Q5: NG base at Airbnb? A: SDE NG base ~$170-180K + equity + sign-on; year-1 total comp ~$260-300K.
Closing
Airbnb's interview isn't "who's grinded more LeetCode" — it's "who can write a production-ready function in an IDE while branding themselves as a host." If you're prepping Airbnb OA or VO, message WeChat Coding0201 with the JD and current loop stage screenshot. We'll scope the role line first, then plan the VO assist / VO live support cadence.
Need real interview material? Add WeChat Coding0201 now to request access.
Contact
- WeChat: Coding0201
- Email: [email protected]
- Telegram: @OAVOProxy