Monday, 8 September - Wednesday, 10 September, 2025 In-Person Only | Amsterdam, Netherlands
The Sched app allows you to build your schedule but is not a substitute for your event registration. You must be registered for GraphQLConf 2025 to participate in the sessions.
Please note: This schedule is automatically displayed in Central European Summer Time (UTC+2). To see the schedule in your preferred timezone, please select from the drop-down located at the bottom of the menu to the right.
IMPORTANT NOTE: Timing of sessions and room locations are subject to change.
Sign up or log in to add sessions to your schedule and sync them to your phone or calendar.
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.
Principal Engineer, Senior Architect (freelance), Bouygues Telecom
A dedicated Senior Solutions Architect & Staff Engineer with a proven ability to lead projects and drive software development initiatives. I thrive in dynamic environments, leveraging my strong technical skills, deep product knowledge and collaborative approach to drive innovation... Read More →
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.
Engineer with decade of experience in software. Worked across platform and product teams at Atlassian. Currently working as an architect in Jira's Issue Domain at Atlassian.
Modernizing a Million Lines of Code: Jira's Journey to GraphQL and Relay, Atlassian
Masters from IIT Roorkee. Engineer with decade of experience in software previously Worked in Amazon & Uber. In Atlassian Using GraphQL to handle JIRA's scale and optimising for better observability, safe rollouts and making JIRA more responsive.
Great documentation has always been the gold standard of API developer experience, and always a real challenge for GraphQL APIs. With the rise of AI and interactive API playgrounds, developer expectations have evolved. Static docs can be slow, confusing, and outdated, while an AI-powered assistant and API playground offer a dynamic, conversational, and instantly actionable experience. In this session, we’ll explore how we at monday.com leveraged AI and interactive tools to replace traditional documentation for our public GraphQL API, reducing friction and accelerating adoption.
Daniel Hai is the API Product Manager at monday.com, leading the strategy behind one of the largest public GraphQL implementations in the industry. With a decade of experience spanning software engineering and product management, he specializes in building APIs that developers love... Read More →
GraphQL federation has changed how we think about data and it's time to adopt that thinking to how we build UIs and component systems. In this talk, Gabe will share his deep experience from building design systems at Apple, Netflix and now StubHub to help you design yours.
What are the advantages GraphQL brings to a traditional React component system? How can fragments optimize the composability of your components? How to reduce duplication while reducing the time you need to ship new features?
We will provide guidance on how to build and leverage a federated component system along-side your design system.
Finally, we will cover how we've leveraged AI to speedup the creation of our design system and federated components at StuHub. Join to learn more!
Senior Software Engineer - Design System Lead, StubHub Inc
Gabriel Cura-Castro is senior software engineer with a particular interest in UX and design systems. He has two decades of experience developing software in a diverse range of fields spanning from developer tools, internet infrastructure, and finance. He has spent the last decade... Read More →
Event Sourcing is emerging as a preferred approach to building complex software systems. It enables rapid development, smooth evolution over time, and opens the door to AI-based acceleration.
We will make a brief introduction to the core concepts of Event Sourcing and why the approach is loved by its adherents. We will review the foundational elements of an Event Sourced application including some common architectural choices.
GraphQL is known for expressive queries, precise data fetching, real-time capabilities, and a strong ecosystem. All of these pair well with Event Sourced applications. GraphQL simplifies the complexity of querying event streams, enables precise control over client-server interactions, and supports flexible schema evolution that is crucial to long term success. We will discuss this in the context of established patterns (and anti-patterns!).
By the end of this talk, attendees will clearly understand how combining Event Sourcing and GraphQL accelerates development and prepares data-driven apps to take advantage of AI-driven acceleration in the near future.
Mike is a practical software leader with an interest in theory, but a stronger interest in getting things done. He's been slinging ones and zeroes for 30 years now and has experience going from five person startups to thousand person enterprises. Mike is currently the CTO of Xolvio... Read More →
Subscriptions are not like queries and mutations. They require specific thinking and care in any implementation strategy. Federation adds a layer of infrastructure that can complicate subscriptions in two ways:
- scaling, because the federation gateway may have to resolve many subscription streams at the same time, - translation, because each subgraph has the protocols it supports, and they may not overlap with the protocol used by the clients.
This lightning talk dives into the challenges of translation we encountered in concrete scenarios:
- How websocket init payloads map, or not, to http headers - How to translate SSE requests to websocket requests - Alternatives like multipart streams - Websocket subprotocols
Tom's professional life has gravitated towards GraphQL and Rust, schemas and databases. After authoring the first Rust GraphQL client library, recent years have taken him from the database schema management space at Prisma to GraphQL federation at Grafbase. In his free time, he enjoys... Read More →
Adopting GraphQL federation creates a convenient place in your infrastructure to make authorization decisions:
- It comes early in the request lifecycle, before any subgraph. - It has access to the whole client request, as well as the entirety of the federated graph. - Authorization can still be the responsibility of the subgraph teams, or a cross cutting concern.
This talk is about leveraging the special position of the federation gateway for authorization.
We'll cover the directives federation offers for authorization out of the box: `@authenticated`, `@requiresScopes`, `@policy`. To cover a more advanced use case, we'll explore how to implement fine-grained authorization taking advantage of data from your federated graph by leveraging extensions in the open source Grafbase Gateway.
Tom's professional life has gravitated towards GraphQL and Rust, schemas and databases. After authoring the first Rust GraphQL client library, recent years have taken him from the database schema management space at Prisma to GraphQL federation at Grafbase. In his free time, he enjoys... Read More →
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
In this talk, we'll explore the design and implementation of a distributed GraphQL router built with Kotlin, leveraging graphql-java and Spring Boot. By using Kotlin’s powerful scripting and DSLs, we can create a highly configurable and scalable solution that simplifies the complexity of managing distributed GraphQL APIs.
Effective caching is essential for building fast, resilient mobile apps especially when aiming for offline-first experiences. Apollo Kotlin and Apollo iOS offer a powerful Normalized Cache component tailored to GraphQL. In this lightning talk, we’ll showcase the latest advancements in both libraries, including support for pagination, cache expiration, and other new features designed to simplify and supercharge cache management on mobile.
Currently working on Apollo-Kotlin, the Kotlin SDK for GraphQL, Benoit has been writing software for 20 years, with a focus on Android since its v1. When he’s not coding, you can find him enjoying movies or geocaching.
Wednesday September 10, 2025 09:00 - 09:10 BST IJzaal
What if your GraphQL schema could do more than provide data? What if it could help your app be more accessible from the start? In this lightning talk, we'll explore an innovative idea of embedding accessibility metadata directly into GraphQL schemas. Inspired by using Kotlin semantics in Jetpack Compose, imagine annotating fields with labels, roles, or screen reader hints that can be used to support screen readers, improve navigation, and even power automated accessibility testing. By adding custom accessibility annotations, tools could generate more accessible UI components, which enhances both the developer experience and the user experience. This is a call to rethink the developer experience and treat accessibility as a first-class concern. Let's reimagine GraphQL not just as a data layer, but as an inclusive design enabler.
Vanessa Johnson is an Android Engineer at The New York Times working on the Games Android app. She loves building mobile apps and any technical topics she finds interesting. She is passionate about accessibility, is working on various side projects, and has a newsletter & a podcast... Read More →
Wednesday September 10, 2025 09:20 - 09:30 BST IJzaal
Managing separate API definitions for REST and GraphQL APIs that serve the same underlying data can be inefficient and lead to duplicated efforts. At Pinterest, we are streamlining our API definitions and unifying our data models with TypeSpec. TypeSpec allows us to define our API shapes once and generate API schemas in multiple forms such as OpenAPI, Protobuf, and now GraphQL!
We’ve developed an open-source TypeSpec GraphQL Emitter which generates valid GraphQL schemas directly from TypeSpec definitions.
Join us for an overview of how TypeSpec and the GraphQL Emitter can streamline your API workflow. We'll explore:
* How TypeSpec's unified definition approach accelerates development across multiple API specs * The inner workings of our open-source GraphQL Emitter * Our wins and lessons learned while building the GraphQL Emitter
This talk will be perfect for anyone interested in GraphQL schema generation, unified API definitions, and vague Lord of the Rings references! See you there!
Fiona Huang is a Senior Software Engineer at Pinterest 📌 working on GraphQL on the Core API Platform team. Previously, she worked on planet scale APIs at Google, GraphQL at Twitter, and APIs at Braintree. Fiona enjoys data modeling 👩🏻💻, coffee ☕, croissants... Read More →
Wednesday September 10, 2025 09:40 - 10:10 BST IJzaal
In theory, data loaders solve most "N+1" problems in GraphQL. In practice, they can be hard to implement, so they’re typically used only in performance-critical situations and often reactively, once inefficiencies surface. To achieve better performance, batching needs to be applied wherever possible.
This talk introduces batch resolvers, a more developer-friendly alternative to data loaders. While traditional GraphQL resolvers take a single input and produce a single output, batching resolvers take a list of inputs and return a list of outputs. A batch resolver can simply call a batch service API without worrying about data loaders.
When a developer provides a batch resolver, our GraphQL server automatically aggregates individual data fetches into a single call to that resolver. It can also apply heuristics to improve aggregation, for example by consolidating different selection sets for the same entity into a single input. This design not only makes application developers’ lives easier, but also allows the server to better optimize query execution by coordinating batch dispatching as part of a broader execution strategy.
Last year we introduced strict error handling - with @throwOnFieldError as an example of how this can be accomplished. This year, we’ll discuss how to safely roll it out.
You’ve had a GraphQL codebase that weakly handled server-side errors for years. Now, you have the tools (directives, hooks, handlers, and language features) that let you treat field errors properly. However, it’s a daunting task to suddenly explode queries en-masse by flipping a switch. This move is powerful, but requires a thoughtful and data-driven approach to do safely.
In this talk we’ll cover: * Preparing the groundwork for migration to stricter error handling * Using data to make informed decisions about fragment/query behavior * Gating your change at a singular point * Scaling the rollout to a large codebase * How we’re approaching this rollout at Meta
Caching is one of the most powerful tools for improving API performance—but in a federated GraphQL architecture, stale data can quickly become a serious challenge. In this session, we will dive into how event-driven patterns can enable precise cache invalidation at the subgraph level, keeping your data fresh without sacrificing speed.
You will learn key design principles, practical integration strategies for GraphQL subgraphs, and the business impact of a smarter caching approach. We will also explore real-world use cases and demonstrate how CloudEvents can standardize event-based workflows across your architecture. Whether you are optimizing an existing caching layer or just beginning your caching journey, this talk will equip you with practical strategies to reduce latency, lower infrastructure costs, and deliver more reliable experiences to your users.
Juan Carlos Blanco Delgado is a software engineer from Venezuela, now residing in the UK and working for RS Group. He is passionate about the Open Source community and holds certifications in AWS and Terraform HashiCorp. Juan Carlos enjoys climbing, cycling, running, snowboarding... Read More →
Wednesday September 10, 2025 11:55 - 12:25 BST IJzaal
When adopting GraphQL, teams diligently follow "best practices" without realizing they're actually choosing between two fundamentally different approaches: designing schemas to serve UI components (frontend-first) or to represent domain models (structure-first). This distinction is rarely framed as an explicit choice in GraphQL literature, with most examples showcasing the structure-first approach by default.
Yet this initial decision shapes everything from your team structure to how you handle breaking changes—and if you start with a structure-first approach, it's especially difficult to unwind that decision later. In this session, we'll explore the critical differences between these philosophies, examine how they manifest in real schemas, and analyze the trade-offs each approach presents. You'll see how changes that feel natural in one approach become deeply problematic in the other, and learn to identify which patterns your team has already begun to follow.
Any company that wants to innovate deals with change. Within GraphQL that often means introducing new fields but also deprecating old fields & types. The faster you can get rid of these old fields & types the less complex your architecture is and less complexity means an easier time building new features!
We saw this problem and got tired of the endless “please migrate away from field X to field Y before Z” emails, which were often not even sent to the right group of consumers!
We automated this process by building a slack bot that uses production analytical data to figure out what clients are using deprecated fields and automated the communication!
Ever wondered if two seemingly different GraphQL queries actually return the same data? Or how to ensure that complex queries—packed with type conditions and directives like @skip/@include—still mean the same thing after a major refactor? In this talk, we’ll explore a novel static analysis technique that efficiently checks whether one query’s response is always a subset of another’s. By performing this subset test in both directions, we can reliably determine query equivalence—bringing new clarity to complex GraphQL operations.
Duckki is an engineer at Apollo GraphQL, working on Apollo Federation. With a decade of experience building static analysis tools to detect bugs and security vulnerabilities, he’s passionate about making GraphQL more reliable and efficient. Duckki holds a PhD from the University... Read More →
Wednesday September 10, 2025 14:45 - 14:55 BST IJzaal
"There are only two hard things in Computer Science: cache invalidation and naming things".
GraphQL provides many benefits over other query languages. Federation builds on top of this foundation to provide even more flexibility and power. But even with all that GraphQL has to offer, the problem of naming remains.
In this talk, Jeff Dolle, from The Guild, will share what he's learned about schema design: proven design philosophies, designing for forward compatibility, exposing errors through types, and tips for how to avoid ambiguous or misleading type names.
Together, we will then go through an example product design meeting: taking user stories and building a complete GraphQL schema.
Jeff Dolle is a Software Engineer at The Guild who has been using GraphQL full-stack since 2016 and is currently working on the GraphQL Hive platform. He has extensive experience designing and implementing schemas in production software, serving over a billion requests a month.
Wednesday September 10, 2025 15:05 - 15:35 BST IJzaal
