Airbnb Placement Papers 2026 – Questions, Answers & Complete Interview Guide

Meta Description: Prepare for Airbnb campus placements 2026 with real placement paper questions, coding problems, system design tips, and HR interview prep. Freshers CTC: ₹25–45 LPA. Complete guide for IIT/NIT students.

---

About Airbnb

Airbnb is one of the world's most iconic travel technology companies, connecting millions of hosts with guests in over 220 countries and regions. Founded in 2008 in San Francisco by Brian Chesky, Joe Gebbia, and Nathan Blecharczyk, Airbnb went from a scrappy startup (literally renting air mattresses) to a global platform worth over $75 billion. The company's platform handles everything from search and discovery to booking, payments, reviews, and host management.

Airbnb's engineering team is responsible for some of the most interesting distributed systems challenges in tech — ranking and recommendation systems that surface relevant listings, dynamic pricing algorithms, fraud detection systems, scalable messaging infrastructure, and a booking engine that must handle millions of concurrent users without a single transaction going wrong. The India technology presence is growing, with engineering roles primarily based in Bengaluru.

For freshers, Airbnb offers compensation in the range of ₹25 LPA to ₹45 LPA, making it one of the more attractive options in the travel tech space. The company culture is mission-driven ("Belong Anywhere"), and employees consistently rate it highly on culture, work-life balance, and engineering quality.

---

Eligibility Criteria

Parameter	Requirement
Degree	B.Tech / B.E. / M.Tech / Dual Degree
Minimum CGPA	7.5 / 10 (8.0+ preferred for top roles)
Active Backlogs	None allowed
Historical Backlogs	Maximum 1 (case-by-case basis)
Graduation Year	2026 batch
Eligible Branches	CSE, IT, ECE, Mathematics & Computing
Experience	Freshers; relevant internship experience valued

---

Airbnb Selection Process 2026

1. Resume Shortlisting – Airbnb recruits prioritize project depth, open-source contributions, internship quality, and relevant side projects (especially anything touching web systems, APIs, or distributed services).

2. Recruiter Call – 20–30 minute call covering background, motivation for Airbnb, and basic technical fluency. This is a "bar check," not a technical screen.

3. Online Coding Assessment – Typically 2 coding problems on HackerRank or Karat. 60–90 minutes. Medium to hard difficulty. Tests core DS&A.

4. Karat Technical Screen (some roles) – A standardized technical interview conducted by a Karat interviewer on behalf of Airbnb. Covers coding, problem-solving, and communication.

5. Virtual Onsite (3–4 rounds):

   • Coding Round 1: Live coding, 1–2 problems, emphasis on problem-solving approach
   • Coding Round 2: More complex problem, possibly with follow-ups (optimize, edge cases)
   • System Design: Design a search/booking system at scale (fresher version: API/DB design)
   • Cross-Functional: Behavioral questions focused on Airbnb's core values

6. Final Offer – After all rounds pass, offer is extended. Typically 2–4 weeks post-interview.

---

Exam Pattern

Section	Questions	Time	Focus Area
Online Coding Assessment	2	60–90 min	DS&A (Arrays, Trees, Graphs)
Live Coding Round 1	1–2	60 min	Problem solving, clean code
Live Coding Round 2	1–2	60 min	Optimization, edge cases
System Design	1 design problem	45–60 min	Scalability, DB design
Behavioral Interview	4–5 questions	45 min	Culture fit, values alignment

---

Practice Questions with Detailed Solutions

Aptitude Questions

---

Q1. A person travels from city A to city B at 60 km/h and returns at 40 km/h. What is the average speed for the entire journey?

Solution:

• Average speed = 2ab/(a+b) where a=60, b=40
• = 2 × 60 × 40 / (60 + 40)
• = 4800 / 100 = 48 km/h

✅ Answer: 48 km/h (Note: Average speed ≠ arithmetic mean of speeds)

---

Q2. In a group of 70 people, 37 like coffee and 52 like tea. How many like both if everyone likes at least one?

Solution:

• Using inclusion-exclusion: |A ∪ B| = |A| + |B| − |A ∩ B|
• 70 = 37 + 52 − |A ∩ B|
• |A ∩ B| = 89 − 70 = 19

✅ Answer: 19 people like both coffee and tea

---

Q3. The simple interest on ₹5,000 for 3 years at 8% p.a. is?

Solution:

• SI = (P × R × T) / 100 = (5000 × 8 × 3) / 100 = ₹1,200

✅ Answer: ₹1,200

---

Q4. In a 4-digit number, the sum of first two digits equals the sum of last two digits and the sum of all digits is 28. What is the second digit if the first is 9?

Solution:

• Let digits be 9, b, c, d
• 9 + b = c + d ... (i)
• 9 + b + c + d = 28 → c + d = 19 − b ... (ii)
• From (i): 9 + b = 19 − b → 2b = 10 → b = 5
• So second digit = 5

✅ Answer: 5

---

Q5. How many 3-digit numbers are divisible by 7?

Solution:

• Smallest 3-digit number divisible by 7: 105 (7 × 15)
• Largest: 994 (7 × 142)
• Count = 142 − 15 + 1 = 128

✅ Answer: 128

---

Q6. A can complete a task in 15 days, B in 20 days. They work together for 5 days, then A leaves. How long does B take to finish alone?

Solution:

• Together: 1/15 + 1/20 = 4/60 + 3/60 = 7/60 per day
• In 5 days: 5 × 7/60 = 35/60 = 7/12
• Remaining = 1 − 7/12 = 5/12
• B alone: (5/12) / (1/20) = (5/12) × 20 = 100/12 ≈ 8.33 days

✅ Answer: 8 days 8 hours (or 25/3 days)

---

Q7. A hostel has food for 200 soldiers for 60 days. If 40 more soldiers join after 10 days, how long will the food last?

Solution:

• Food consumed in 10 days = 200 × 10 = 2000 units
• Remaining food = 200 × 60 − 2000 = 12000 − 2000 = 10000 units
• After 10 days, soldiers = 200 + 40 = 240
• Remaining days = 10000 / 240 = 41.67 days ≈ 41 days 16 hours

✅ Answer: ~41.67 days remaining

---

Coding Questions

---

Q8. Search in a 2D Matrix — Find a target in a row-wise and column-wise sorted matrix.

def search_matrix(matrix, target):
    """
    Start from top-right corner.
    If current > target: move left
    If current < target: move down
    """
    if not matrix or not matrix[0]:
        return False
    
    rows, cols = len(matrix), len(matrix[0])
    row, col = 0, cols - 1  # Start top-right
    
    while row < rows and col >= 0:
        if matrix[row][col] == target:
            return True
        elif matrix[row][col] > target:
            col -= 1  # Go left
        else:
            row += 1  # Go down
    
    return False

# Example
matrix = [
    [1,  4,  7,  11],
    [2,  5,  8,  12],
    [3,  6,  9,  16],
    [10, 13, 14, 17]
]
print(search_matrix(matrix, 5))   # True
print(search_matrix(matrix, 20))  # False

# Time: O(m + n), Space: O(1)

---

Q9. Design Airbnb's Search Feature — Nearest Available Listings (K-D Tree concept simplified).

import heapq
from typing import List, Tuple

class Listing:
    def __init__(self, id: str, lat: float, lon: float, price: float, rating: float):
        self.id = id
        self.lat = lat
        self.lon = lon
        self.price = price
        self.rating = rating

def find_nearest_listings(listings: List[Listing], user_lat: float, 
                          user_lon: float, k: int) -> List[Listing]:
    """Find K nearest listings to user's location."""
    
    def distance(listing):
        return ((listing.lat - user_lat) ** 2 + (listing.lon - user_lon) ** 2) ** 0.5
    
    # Min-heap by distance
    heap = [(distance(l), i, l) for i, l in enumerate(listings)]
    heapq.heapify(heap)
    
    result = []
    for _ in range(min(k, len(heap))):
        _, _, listing = heapq.heappop(heap)
        result.append(listing)
    
    return result

# Time: O(n log k), Space: O(n)
# In production: use PostGIS or Elasticsearch geo queries

---

Q10. Decode Ways — Count number of ways to decode a digit string (Classic DP).

def num_decodings(s: str) -> int:
    """
    'A'-'Z' map to '1'-'26'
    Count distinct decodings of string s.
    """
    if not s or s[0] == '0':
        return 0
    
    n = len(s)
    dp = [0] * (n + 1)
    dp[0] = 1  # Empty string
    dp[1] = 1  # First character (non-zero)
    
    for i in range(2, n + 1):
        one_digit = int(s[i-1])
        two_digit = int(s[i-2:i])
        
        if one_digit >= 1:
            dp[i] += dp[i-1]
        if 10 <= two_digit <= 26:
            dp[i] += dp[i-2]
    
    return dp[n]

# Examples
print(num_decodings("12"))   # 2 → "AB" or "L"
print(num_decodings("226"))  # 3 → "BZ", "VF", "BBF"
print(num_decodings("06"))   # 0 → invalid

# Time: O(n), Space: O(n) — can optimize to O(1)

---

Q11. Meeting Rooms II — Minimum number of meeting rooms needed.

import heapq

def min_meeting_rooms(intervals):
    """
    Find minimum conference rooms needed to schedule all meetings.
    Airbnb relevance: scheduling host availability slots.
    """
    if not intervals:
        return 0
    
    intervals.sort(key=lambda x: x[0])
    heap = []  # Min-heap of end times
    
    for start, end in intervals:
        if heap and heap[0] <= start:
            heapq.heapreplace(heap, end)  # Reuse room
        else:
            heapq.heappush(heap, end)  # Need new room
    
    return len(heap)

# Example
meetings = [[0,30],[5,10],[15,20]]
print(min_meeting_rooms(meetings))  # 2

meetings2 = [[7,10],[2,4]]
print(min_meeting_rooms(meetings2))  # 1

# Time: O(n log n), Space: O(n)

---

Q12. Implement a Booking System with Conflict Detection.

class BookingSystem:
    """
    Airbnb-style: Book a property for date ranges.
    Detect conflicts before confirming.
    """
    def __init__(self):
        self.bookings = {}  # property_id -> list of (start, end) tuples
    
    def book(self, property_id: str, start: int, end: int) -> bool:
        """Returns True if booking successful, False if conflict."""
        if property_id not in self.bookings:
            self.bookings[property_id] = []
        
        existing = self.bookings[property_id]
        
        for s, e in existing:
            # Check for overlap: two intervals overlap if start < e and end > s
            if start < e and end > s:
                return False  # Conflict detected
        
        existing.append((start, end))
        return True  # Booking confirmed
    
    def cancel(self, property_id: str, start: int, end: int) -> bool:
        if property_id not in self.bookings:
            return False
        try:
            self.bookings[property_id].remove((start, end))
            return True
        except ValueError:
            return False

# Test
bs = BookingSystem()
print(bs.book("villa_001", 1, 5))    # True  (days 1-5)
print(bs.book("villa_001", 6, 10))   # True  (days 6-10, no overlap)
print(bs.book("villa_001", 4, 7))    # False (overlaps with both!)
print(bs.book("villa_001", 10, 15))  # True  (starts exactly when other ends)

---

Q13. Flatten a Nested List — useful for Airbnb's experience/category hierarchy.

def flatten(nested_list):
    """Flatten arbitrarily nested list structure."""
    result = []
    
    def dfs(lst):
        for item in lst:
            if isinstance(item, list):
                dfs(item)
            else:
                result.append(item)
    
    dfs(nested_list)
    return result

# Example
data = [1, [2, 3], [4, [5, 6]], 7, [[8, 9], 10]]
print(flatten(data))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Iterative version (better for very deep nesting — avoids recursion limit)
def flatten_iterative(nested_list):
    stack = [nested_list]
    result = []
    while stack:
        current = stack.pop()
        if isinstance(current, list):
            stack.extend(reversed(current))
        else:
            result.append(current)
    return result

---

Q14. Serialize and Deserialize a Binary Tree.

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Codec:
    def serialize(self, root):
        """Encode tree to string using pre-order DFS."""
        if not root:
            return "null"
        return f"{root.val},{self.serialize(root.left)},{self.serialize(root.right)}"
    
    def deserialize(self, data):
        """Decode string back to tree."""
        values = iter(data.split(','))
        
        def helper():
            val = next(values)
            if val == "null":
                return None
            node = TreeNode(int(val))
            node.left = helper()
            node.right = helper()
            return node
        
        return helper()

# Time: O(n), Space: O(n) — where n = number of nodes

---

Q15. Airbnb-style: Review Aggregation — Find average rating per city.

from collections import defaultdict

def aggregate_reviews(reviews):
    """
    Input: list of (listing_id, city, rating) tuples
    Output: dict of city -> average_rating
    """
    city_data = defaultdict(lambda: [0, 0])  # [total_rating, count]
    
    for listing_id, city, rating in reviews:
        city_data[city][0] += rating
        city_data[city][1] += 1
    
    return {
        city: round(total / count, 2)
        for city, (total, count) in city_data.items()
    }

# Example
reviews = [
    ("l001", "Goa", 4.8),
    ("l002", "Goa", 4.2),
    ("l003", "Mumbai", 4.5),
    ("l004", "Bengaluru", 3.9),
    ("l005", "Bengaluru", 4.7),
    ("l006", "Mumbai", 4.0),
]

print(aggregate_reviews(reviews))
# {'Goa': 4.5, 'Mumbai': 4.25, 'Bengaluru': 4.3}

# Time: O(n), Space: O(cities)

---

HR Interview Questions with Sample Answers

Q1. Why Airbnb? What draws you to the travel tech space?

"Airbnb's impact is deeply human — it's not just about technology, it's about enabling people to belong anywhere in the world. The engineering challenges that come from that mission are fascinating: how do you build a search ranking system that surfaces the perfect listing for each user? How do you handle fraud at the scale of millions of transactions daily? The intersection of personalization, trust, and payments is exactly the kind of complex domain I want to build in. Also, the 'belong anywhere' mission genuinely resonates with me personally — I've seen how travel transforms perspectives."

---

Q2. Tell me about a project you're most proud of.

"I built a hostel booking webapp during my second year — partly out of frustration with how clunky the booking experience was on our college's existing system. I designed the database, built the backend in Django REST Framework, and a React frontend. The highlight was implementing a conflict detection algorithm for bookings — no double-booking, real-time availability updates using WebSockets. It's running on a small server and a few thousand students have used it. That's the closest I've come to Airbnb's core problem, and it made me appreciate how hard real-world booking systems are at scale."

---

Q3. Describe a time you disagreed with a teammate and how you handled it.

"During my team's capstone project, I wanted to use PostgreSQL and a teammate insisted on MongoDB. We both had valid points. I set up a quick benchmark test with our actual data model and documented the tradeoffs. The data showed that our schema was very relational and PostgreSQL performed 40% better for our queries. We went with Postgres — but I made sure to acknowledge the valid use cases for MongoDB too. The key was keeping it data-driven, not emotional."

---

Q4. How would you improve Airbnb's product?

"I think Airbnb's biggest opportunity is in dynamic trip planning — right now, you find a listing and then separately figure out experiences, transport, and local tips. If Airbnb built a lightweight itinerary layer — 'book listing + experiences + local transport in one flow' — it would increase basket size and reduce drop-off. The data Airbnb already has on what experiences guests near a specific listing book could power this really well."

---

Q5. Where do you see yourself in 3 years?

"In 3 years, I want to be a senior engineer who has shipped features that directly improved the booking experience for users at scale. I'd love to go deep on Airbnb's search and ranking systems — that's where ML meets engineering and business impact in the most interesting way. I also want to mentor junior engineers by then; teaching forces you to understand things at a deeper level."

---

Preparation Tips

• Study Airbnb's engineering blog — medium.com/airbnb-engineering has brilliant posts on search ranking, distributed transactions, and data infrastructure. Reference them in interviews.
• Deep-dive into graph algorithms — Airbnb's recommendation system uses graph-based approaches. Practice Dijkstra's, BFS/DFS, topological sort.
• Understand booking system design — Study conflict detection, real-time availability, and distributed locking — all core to Airbnb's backend.
• Practice behavioral questions using their core values — "Belong Anywhere", "Champion the Mission", "Be a Host" — map your stories to these values explicitly.
• Build a travel-related project — Even a small travel planning app or booking API demonstrates domain relevance and passion.
• LeetCode medium is the baseline — Aim to consistently solve mediums in 20–25 minutes. Hard problems appear but mediums are most common.
• Know your data structures cold — Arrays, Hash Maps, Heaps, Trees, Graphs — implement them from scratch if needed. Airbnb interviewers value depth.

---

Frequently Asked Questions (FAQ)

Q1. What is Airbnb's fresher salary package in India 2026? Freshers at Airbnb India can expect a total CTC of ₹25 LPA to ₹45 LPA, comprising base salary, RSUs (vesting over 4 years), and performance bonus. The exact figure depends on the role and offer negotiation.

Q2. Does Airbnb hire from non-IIT colleges? Yes. While IITs and BITS are preferred targets, Airbnb hires based on demonstrated skills. A strong GitHub profile, quality projects, and excellent interview performance can compensate for college tier. Off-campus applications through their careers page are very viable.

Q3. What is the Karat interview that Airbnb uses? Karat is a specialized interview company that conducts technical screens on behalf of companies like Airbnb. The Karat interview is a live coding session (45–60 min) with a Karat engineer. It's essentially a technical screen — treat it like any other coding round.

Q4. Is there an on-site interview or is everything virtual? Since 2020, Airbnb primarily conducts virtual onsite interviews via Zoom/CoderPad. With increased India hiring, some candidates may be invited to the Bengaluru office, but virtual is standard.

Q5. How long does Airbnb's hiring process take from application to offer? The end-to-end process typically takes 3–6 weeks from initial application to offer letter. Campus hiring moves faster (2–3 weeks during placement season); off-campus can take longer.

---

Last updated: March 2026 | Tags: Airbnb Placement Papers 2026, Airbnb Interview Questions India, Airbnb Fresher Salary India, Travel Tech Jobs India 2026