GraphQLConf 2025

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!

Rate limiting in GraphQL APIs goes beyond the traditional approaches used in REST APIs. Regular techniques fall short when handling complex queries and preventing abuse. In this lightning talk, we will explore creative strategies for overcoming these challenges within the unique context of GraphQL's single endpoint architecture. We will also discuss practical techniques and dive into real-world examples that demonstrate how to optimize rate limiting in your GraphQL APIs and ensure the scalability and security of your applications.

GraphQL provides flexibility in fetching data but this can prove challenging for caching. In this talk I cover the basics of caching in GraphQL such as layers you can cache at a high level. Layers such as the CDN, client side, server side, and database are touched upon with solutions from the community. The talk will also cover when to use each layer and what statistics to look at for improvement. I talk about how caching at multiple layers provides the best experience for the end user. By the end of this talk beginners will have a path forward to how they can cache at different layers for better performance.

There are many aspects to consider when building a GraphQL API: Authentication, authorization, performance, schema design, and team workflow to name a few. Each aspect encompasses considerations, practices, and tools (or lack thereof). One aspect, documentation, can be easily neglected. At The Guild we are building an open source tool called Polen to address this. It aims to make beautiful developer portals easy and reduce the gap of docs tools between GraphQL and REST communities.

This presentation would mark the first formal introduction of Polen, covering:

1. How/why Polen came to be
2. What it does so far
3. What it could do in the future

This talk would continue the larger docs conversation (e.g. last year https://www.youtube.com/watch?v=kWe_v6YVj8U) by sharing what encoding some of our best docs ideas into tooling could look like. Ideally it would help the audience think about how they can make their APIs more accessible for their users. Finally, given Polen is not a commercial offering, I also hope to inspire people to get involved, make issues, give feedback, and send pull requests.

Polen is already public today at http://github.com/the-guild-org/polen

One of the great achievements of GraphQL is composable, full-stack type safety: a strongly-typed schema, against which one writes client components, and from which minimal yet sufficient queries are generated. This seamless flow from database to UI, with immediate feedback, compile-time guarantees and great performance, represents an unmatched DevEx breakthrough.

But what if we use a full-stack client (like Isograph aims to be)? Or use a rich client in combination with a Hasura, Prisma or PostGraphile, and effectively write components against an SQL schema? Have both the GraphQL schema and its operation language become mere implementation details?

In this talk, I'll explore how GraphQL's apparent disappearance into tooling actually represents its ultimate victory. Even as GraphQL-the-syntax fades from view, its architectural innovations—fragment composability, full-stack type safety, document merging, persisted operations—become the invisible foundation of modern development.

The best way to honor this legacy isn't to protect its syntax — it's to let its principles be reborn in new forms, evolving as our tools evolve, making app development better for years to come.

`useQuery` is a powerful and simple abstraction, but there is so much more to Apollo Client today. In this talk we’ll re-introduce Apollo Client for this new era. Query preloading, suspense, fragment APIs, and data masking have given GraphQL practitioners a toolset to build sophisticated, scalable, and highly performant applications like never before. Learn about these new APIs, upgraded tooling, and how version 4.0 (and beyond) gives users a leaner, cleaner, and more capable open source GraphQL client.

Imagine you have a decade old REST API codebase with thousands of daily commits by hundreds of engineers, how would you incrementally adopt GraphQL? How would the data models be compatible with both REST and GraphQL to avoid divergence? How…?

We will share Instagram’s journey from 100% REST API development to 95%+ new APIs developed in GraphQL over a two year period.

Mediaset, one of Europe largest free broadcasters, owns and manages more than ten consumer-facing applications across web, mobile, and smart TV platforms, leading the Media and Entertainment ecosystem in Italy and Europe. Historically, each of these apps (managed by distinct development teams) interacted directly with several different backend APIs to serve content to customers, resulting in redundant development efforts, inconsistencies between platforms and enormous and useless network transfers.

In this session we will present how, by creating a carefully designed GraphQL schema, we managed to transition each of them to a more streamlined approach, where the backend complexity and variety is hidden from the frontend integrations. We will dive into the choices made, the GraphQL features that we leveraged (one among all, Trusted Documents to exploit CDNs and improve security), the issues that we've encountered while building the system, and the benefits that we gained from all perspectives: user experience, development perspective, feature delivery and time to market.