GraphQLConf 2025

Have you ever wondered how GraphQL clients like Relay keep local data consistent across surfaces, ensuring that changes made within a session are seamlessly reflected across an application? In this talk, I'll delve into the concept of Local Data Consistency and explore how GraphQL clients at Meta, such as Relay, efficiently track and update changing GraphQL data locally, without introducing additional networking dependencies, and the UX benefits and features this unlocks.

Specifically, I’ll cover:
- What even is Local Data Consistency, and why is it valuable to product developers?
- How do you implement a data consistency engine from scratch?
- How are advanced client-side features like offline mutation updates, asynchronous GraphQL request fetching, and more all made possible using a Local Data Consistency?

What started as a single developer's passion project now powers mission-critical APIs for tech giants like Twitter/X, Netflix, Amazon, AirBnB, and Atlassian. As the engine behind Spring for GraphQL and with over 2.2 million monthly downloads, GraphQL Java has become the Java implementation of GraphQL.

How does a volunteer-driven open source project not just survive, but thrive for a decade? In this talk, we'll share the crucial technical decisions and community building strategies that transformed a hobby project into an industry standard. We'll share how we fostered contributions from over 250 volunteers while maintaining high code quality and project momentum. You'll walk away with actionable insights to help you lead any software project, whether it's open source or enterprise.

About the speakers: we are the maintainers of GraphQL Java, who have guided the project from its first commit to becoming the industry standard.

Buffer’s Public API has long enabled developers to build tools that amplify the power of social media management. However, as the landscape of social platforms and developer needs has evolved, so too have the requirements for a robust, secure, and developer-friendly API. In this talk, we'll share our journey as we rebuild Buffer’s public API from the ground up, embracing modern GraphQL principles and best practices.

Attendees will get an inside look at our design decisions, from intuitive schema design to robust authentication, and how we’re ensuring a smooth migration path for existing users. We’ll explore how we’re balancing the needs of our developer community with evolving platform policies and technical constraints.

Traditional GraphQL servers execute queries field by field with a depth-first algorithm as defined in the GraphQL specification. In contrast, GraphQL federation gateways need to partition the query and retrieve chunks of data from external data sources, creating new challenges. We'll present how we solved those challenges with a focus on performance.

The first, query planning, is to find the best possible plan with the multiple possibilities federation offers to unify your data and the various data sources with their requirements. We express this problem as a graph of possibilities and solve it as a Steiner Tree problem. The second challenge is performant execution. As we need to read and write overlapping chunks of the response in parallel, it's hard to be as efficient as a traditional GraphQL server writing a response iteratively with independent fields. We build an execution DAG with field dependencies, parallelizing work as much as possible without any lock on the response. We also pre-compute the expected data shape to ingest and validate incoming data into the response without any intermediate memory allocation.

HotelPage Service (HPS) is one of the busiest, most business-critical systems at Booking.com — originally built as a REST API with Protobufs for speed and structure. It was fast but rigid. As product demands grew and clients needed more flexibility, cracks began to show: over-fetching, unclear ownership, and slow iteration cycles.

This talk shares our real-world journey of modernizing that stack with GraphQL — not just adopting it as a new interface, but transforming how teams design schemas, collaborate across domains, and scale under load. We’ll walk through how we evolved from a proto-backed monolith to a federated GraphQL architecture — improving performance, enabling resolver ownership, and making the schema reflect real product needs.

Whether you're planning a GraphQL migration or scaling one across teams, this talk delivers actionable insights and hard-won lessons from operating at billions of requests per day.

Attendees will gain:
- Align schema design with client and product needs
- Handle organisational complexity in federation
- Avoid pitfalls like over-fetching and the N+1 trap
- Drive resolver ownership and collaboration
- Optimise execution paths under high traffic

Imagine having a federated GraphQL query builder customized to meet unique software infrastructure requirements—have you ever dreamed of such a tool? If so, please join us for an exciting session where we uncover LinkedIn’s code first approach to querying entity-oriented data with federated GraphQL on top of backend gRPC services. Discover how our solution leverages the advanced capabilities of gRPC for enhanced performance, low latency, and multi-language support, while achieving seamless integration with our established Rest.li framework. We will dive into the motivations behind adopting this strategy, the intricate challenges encountered, and the significant improvements in developer experience and productivity it brings. With real-world examples and performance benchmarks, witness how this approach modernizes our service infrastructure, leading to more efficient and scalable solutions.

In this talk, I will discuss recent developments in GraphiQL, including compiling source code with the React Compiler, support for React 19, migration to Zustand for state management, and the long-awaited transition to the Monaco Editor.

Error handling is a critical aspect of developing robust GraphQL applications. Misuse or misunderstanding of errors can lead to applications that fail to function correctly, causing frustration for both developers and users.

In this talk, we explore how to effectively manage errors in GraphQL, ensuring they are wrapped in a useful way, the implementation details are hidden behind them, and common design pitfalls are avoided.