How Airbnb is Moving 10x Faster at Scale with GraphQL and Apollo

Imagine a bustling airport where every passenger has a unique itinerary, and the ground crew must coordinate thousands of flights in real-time. Now, imagine if the crew had to manually check each passenger’s details across multiple systems every time a change occurred. Chaos, right? This is the challenge Airbnb faced with its monolithic REST API, which struggled to handle the growing complexity of its platform. Enter GraphQL and Apollo, the dynamic duo that helped Airbnb move 10x faster at scale.

In this blog post, we’ll explore how Airbnb adopted GraphQL and Apollo to modernize its API infrastructure, improve developer productivity, and deliver a seamless experience for millions of users. Whether you’re a backend engineer, a frontend developer, or a tech enthusiast, this deep dive will provide valuable insights into building scalable and efficient APIs.

The Problem with REST

Airbnb’s platform relies on a complex web of services and data sources, from property listings and user profiles to payment systems and search algorithms. Initially, the company used REST APIs to serve data to its clients (web and mobile apps). However, as the platform grew, several challenges emerged:

• Over-fetching and Under-fetching: REST APIs often returned more or less data than needed, leading to inefficiencies.
• N+1 Query Problem: Fetching related data required multiple round trips to the server, increasing latency.
• Rigid Schema: REST endpoints were tightly coupled to specific use cases, making it difficult to adapt to changing requirements.
• Developer Productivity: Frontend teams had to wait for backend changes to implement new features, slowing down development.

Why GraphQL and Apollo?

GraphQL, a query language for APIs, and Apollo, a powerful GraphQL implementation, offered a solution to these challenges:

• Declarative Data Fetching: Clients can request exactly the data they need, no more, no less.
• Single Endpoint: GraphQL provides a single endpoint for all queries, reducing complexity.
• Real-time Updates: Subscriptions enable real-time data synchronization.
• Tooling and Ecosystem: Apollo’s tools, such as Apollo Client and Apollo Server, streamline development and debugging.

For Airbnb, adopting GraphQL and Apollo was a game-changer, enabling teams to move faster and deliver better user experiences.

The Migration Process

1. Building a Proof of Concept

To validate GraphQL’s potential, Airbnb’s engineering team created a proof of concept (PoC) for a small part of the platform. The PoC demonstrated that GraphQL could:

• Reduce payload sizes by up to 50%.
• Cut latency by eliminating unnecessary round trips.
• Improve developer productivity with self-documenting APIs.

2. Incremental Adoption

Instead of rewriting the entire API at once, Airbnb adopted GraphQL incrementally:

• New Features: All new features were built using GraphQL.
• Existing Features: Legacy REST APIs were gradually migrated to GraphQL.
• Hybrid Approach: Apollo’s schema stitching allowed REST and GraphQL APIs to coexist seamlessly.

3. Tooling and Automation

To streamline the migration, Airbnb invested in tooling and automation:

• Code Generation: Apollo’s codegen tools automatically generated TypeScript types and React hooks from GraphQL schemas.
• Monitoring and Analytics: Apollo Engine provided insights into query performance and error rates.
• Developer Onboarding: Comprehensive documentation and training helped teams adopt GraphQL quickly.

Technical Challenges and Solutions

Challenge 1: Schema Design

Designing a scalable and maintainable GraphQL schema for a platform as complex as Airbnb was no small feat.

Solution:

• The team followed best practices, such as using descriptive type names and avoiding overly nested structures.
• They used schema stitching to combine multiple GraphQL schemas into a single unified schema.

const { stitchSchemas } = require('@graphql-tools/stitch');

const listingsSchema = makeExecutableSchema({ typeDefs: listingsTypeDefs, resolvers: listingsResolvers });
const usersSchema = makeExecutableSchema({ typeDefs: usersTypeDefs, resolvers: usersResolvers });

const gatewaySchema = stitchSchemas({
  subschemas: [listingsSchema, usersSchema],
});

Challenge 2: Performance Optimization

GraphQL’s flexibility can sometimes lead to performance issues, such as deeply nested queries or inefficient resolvers.

Solution:

• The team implemented query cost analysis to limit the complexity of queries.
• They used DataLoader to batch and cache database requests, reducing the N+1 query problem.

const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
  const users = await db.users.find({ id: { $in: userIds } });
  return userIds.map((id) => users.find((user) => user.id === id));
});

const resolvers = {
  Query: {
    user: (_, { id }) => userLoader.load(id),
  },
};

Challenge 3: Real-time Updates

Airbnb needed real-time updates for features like messaging and booking notifications.

Solution:

• The team used GraphQL subscriptions to push real-time updates to clients.
• They integrated Apollo with WebSocket for efficient communication.

const { PubSub } = require('apollo-server');

const pubsub = new PubSub();

const resolvers = {
  Subscription: {
    bookingUpdated: {
      subscribe: () => pubsub.asyncIterator(['BOOKING_UPDATED']),
    },
  },
};

Lessons Learned

1. Start Small: Begin with a PoC to validate the technology and build team confidence.
2. Adopt Incrementally: A phased approach minimizes risks and allows for continuous learning.
3. Invest in Tooling: Tools like Apollo Client and DataLoader can significantly improve productivity.
4. Monitor Performance: Use analytics to identify and address performance bottlenecks.
5. Empower Developers: Provide training and resources to help teams adopt GraphQL effectively.

The Future of GraphQL at Airbnb

Airbnb’s adoption of GraphQL and Apollo is still ongoing, but the results so far are impressive. The team plans to:

• Migrate more legacy APIs to GraphQL.
• Explore advanced features like persisted queries and schema federation.
• Contribute to the GraphQL and Apollo communities by open-sourcing tools and best practices.

By embracing GraphQL and Apollo, Airbnb is not only improving its API infrastructure but also setting a benchmark for modern API development. You can read more details here: How Airbnb is Moving 10x Faster at Scale with GraphQL and Apollo.