GraphQLConf 2025

Large enterprises often benefit from numerous teams executing a wide array of operations, each with its own specifications. Bouygues Telecom in France is a prime example, boasting over 1,700 swagger endpoints (and counting). This diversity often leads to challenges such as path and schema conflicts. We will demonstrate to our audience how we overcame these obstacles by leveraging the guild's comprehensive toolkit to create a unified Knowledge Graph that serves our entire enterprise.

What if you could keep traditional UI pagination concepts, but with the performance and reliability of cursor-based pagination? In this lightning talk, you’ll learn how relative cursors enable fast, consistent pagination while preserving familiar UX patterns like “jump to page.” It’s a smarter, more robust approach to navigating data—ideal for modern APIs and real-world apps.

Abstract
Discover how we transformed Jira's issue view to GraphQL and Relay—handling billions of monthly interactions across 100+ field types while meeting enterprise compliance and reliability agreements. With hundreds of developers and teams modifying a decade-old codebase daily in a frontend monorepo, we faced unique challenges in technical design and execution.
We'll share:
- GraphQL schema design for scale
- Bridging Redux, Sweet State, and Relay in a multi-team environment
- Incremental rollout strategies with feature flags for safe migration
- Field-by-field adoption approaches maintaining workflow and compliance
- Performance optimization under enterprise-scale load
- Testing approaches at scale
- Developer experience takeaways

Impact & Takeaways
- Performance metrics during incremental migration
- Developer experience improvements
- Cross-team collaboration
- Production-proven strategies for state management in existing codebase

This isn't about building new—it's about modernizing Jira's critical interface while maintaining compliance for enterprise customers. Ideal for leaders coordinating teams and architects planning GraphQL adoption in regulated organizations.

@defer allows you to specify which parts of your operation are urgent, and which can be delayed. However, there is still a contract with @defer: all your data will always be returned, at some later point.

This poses a problem for certain classes of product: if only 10% of your operation will ever be on consumed, but you don't know exactly which 10% that will be, defer can introduce substantial hidden costs. To improve performance and reduce compute costs, Meta created @async to ensure products only ask for data when it's needed.

To ease life for the roughly 1,000 developers who contribute regularly to our GraphQL interface, Airbnb has a highly opinionated developer API that we believe eases life for both developers and the operators who maintain the service. In the past, this API was implemented on top of a traditional, specification-based GraphQL engine, which supported agility as we evolved our opinionated approach to resolvers. As that approach matured, we saw opportunities to build a more efficient engine to support them.

This talk describes our new GraphQL engine. Key elements in our design include:

- Refactoring query execution into distinct resolution and completion phases.

- A query planner that optimizes and orchestrates the execution of those phases.

- A new data structure that is the intermediary between the two phases, a data structure that allows for principled communication between the many resolvers involved in executing a query

A talk covering the journey of The Guild building a query planner for the future. We are going to share our journey learnings, insights and real-life examples on how we built our open-source Federation query planner.

In this talk, we’ll cover:

- The background and journey The Guild did (from composition to query planning)
- An overview of our query planner architecture
- Audit-based development
- Why we build our query planner as a library
- Next steps and the community can get involved

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?

We will explore the novel static analysis approach used by Grats to enable a true implementation-first developer experience for building GraphQL servers in TypeScript.

If you are interested in compilers, type systems, static analysis and developer experience, this talk is for you!