GraphQLConf 2026

React Server Components (RSC) and GraphQL have considerable overlap in the problems they seek to solve. This makes them competitors in some scenarios.

In this talk we’ll recount the origins of RSCs at Meta as a prototype within the Relay GraphQL client, discuss how to choose between the two technologies, and end with an exploration of architectures in which they both might reasonably coexist moving forward.

How do you make one of the world's largest federated graphs accessible to token-constrained LLM minions?

With hundreds of teams contributing to or consuming GraphQL APIs at Netflix, good tools are critical. Today, our GraphQL platform supports engineers across the entire dev lifecycle. However, the nature of developer tooling is rapidly changing.

It’s no longer enough to have a pretty UI if LLMs can’t access it—”agent-friendly” is now table stakes.

In this talk, we'll discuss how our tools have adapted to expose agent-friendly interfaces, allowing agents to seamlessly interact with and utilize them for exploring the graph, building queries, designing schemas, and more.

Finally, how can we leverage the power of AI within the tools themselves? We’ll discuss techniques for superpowering GraphQL tooling via focussed agents with guardrails and feedback loops, increasing accuracy and trust.

Pretty much every major GraphQL execution implementation follows the same pattern: depth-first traversal. But the spec doesn’t require this. At Shopify, we challenged that status quo and rewrote GraphQL execution to run breadth-first.

Here’s how it works: instead of running a field resolver repeatedly across each object in a list during its depth pass, we execute each field resolver only once per selection with a complete breadth of objects spanning the response. The napkin math is compelling—5 fields resolved across a list of 100 objects running depth-first will produce 500 resolver calls + lazy promises, while running breadth-first will only produce 5. We’ve seen dramatic results with some large list queries shaving many seconds off their end-to-end response times.

This talk will cover:

* Why depth-first has hidden costs that scale linearly.
* How breadth-first inverts the cost model.
* Why dataloaders are a hack.
* The trade-offs we accepted.
* How we're incrementally migrating to breadth execution.

If you've ever been concerned that CPU-bound GraphQL performance doesn't scale well, this talk offers a new perspective—and proof that challenging conventions can pay off.

Optimizing wire size is in WhatsApp's DNA. In the early days, we transformed verbose XML into a compact binary protocol (WAP) that helped us serve users worldwide on constrained networks. Now, as we migrate to GraphQL, we faced a new challenge: JSON responses were 30% larger than WAP-encoded equivalents. This talk tells the story of how we solved that problem—by leveraging GraphQL's type system to outperform not just JSON, but WAP and protobufs too. We'll share the technical approach (implementing Argo), the results (27-50% smaller responses), and why this represents the next evolution in efficient data transfer for Meta's apps.

After eleven years as an open source technology, GraphQL has never had a more favorable learning curve. Clearer mental models, better educational materials, and a deeper collective understanding of best practices have transformed the “wild west” of 2015 to a much more manageable landscape today.

You and your team are unique, so rather than a one-size-fits-all blueprint I thought I’d present a practical guide to teaching yourself GraphQL in 2026. We’ll examine how beginners typically build their first mental model of GraphQL, the most common misconceptions, and the key design questions they encounter early. Special attention will be paid to different modalities: schema-first vs. code-first, schema design principles, common pitfalls when considering enums, the proper use of fragments, and security and performance by default.

Attendees will leave with a conceptual roadmap for self-study, a recipe book for context engineering in their agent, and an understanding of the major decision points along the journey ahead.

In GraphQL, a resolver is defined as “the internal function for determining the resolved value of a field.” Traditionally, resolvers live exclusively on the server—but should they? Many teams find themselves either duplicating business logic on the client or pushing client-specific concerns into backend code when trying to treat server models as view models.

This talk explores an alternative: client-side resolvers. With Relay Resolvers, clients can define fields that combine and transform data locally. We'll walk through how they work and guidance for deciding when logic belongs on the server versus the client.

Deprecating fields and removing them in GraphQL is tricky itself, but tooling can help identifying such based on statically analysing operations or traffic. But, deprecating inputs is a whole different challenge! Once clients start sending arguments or input object fields, removing or changing them can break integrations in subtle ways, as you do not know which fields might be used in the future and which ones might not, especially if you are running GraphQL at scale. In this lightning talk we will explore possible options for making this whole process more safe in the present, and dip into how it could look in the future!

In high-stakes industries, a GraphQL schema is more than a technical contract—it is a live map of your enterprise’s risk surface. For security teams, schema modifications are often "black box" events that threaten data integrity. To scale safely, we must move beyond manual gatekeeping to a Zero-Trust Supergraph where security is an invisible, automated fortress.

We will present a framework for Embedded Governance to bridge engineering and enterprise risk. Learn how to transform your graph's technical "menu" into a transparent Data Marketplace with radical observability, ensuring built-in security and compliance.

Attendees will learn to:
- Navigate the Risk Primer: Translate GraphQL features (types, fields, directives) into risk language to build organizational trust.
- Shift Security Left: Automate security with secure frameworks & replacing manual reviews.
- Architect for Data Isolation: Use of fine grained access to manage entitlements and prevent unauthorized data exposure.
- Harden the Control Plane: Reduce attack surface using technical strategies like disabling introspection and enforcing persisted query ownership.

What we will cover:
The "All-or-Nothing" Barrier: We'll analyze the limitations of traditional Document Caching in GraphQL. We will explain why a single personalized field or a volatile "live" value can invalidate an entire response, leading to low cache hit rates and overloaded origin servers.

Partial Query Caching (PQC) Architecture: We will introduce a granular approach to caching. You'll learn how to decompose complex queries into atomic components, separating static fragments from dynamic ones within the same request to dramatically boost cache efficiency.

The Power of the Edge: We'll discuss the benefits of moving the "split-and-merge" logic to the Edge. We will explain how an intelligent Gateway can manage this complexity close to the user, saving expensive compute resources at the origin and reducing latency.

The Next Frontier: PQC meets @defer: To wrap up, we'll demonstrate how combining caching with the GraphQL @defer directive allows us to return cached fragments in milliseconds while streaming the remaining dynamic parts as they resolve.

This presentation explores production-scale GraphQL architecture on AWS, demonstrating how to handle millions of requests and complex data operations at enterprise scale. Drawing from real-world pricing systems that serve thousands of internal clients, we'll examine the architectural decisions behind building resilient, high-performance GraphQL services using AWS AppSync, Lambda, and DynamoDB. The session covers critical
production considerations including query optimization strategies, caching layers, connection pooling, and event-driven architectures that power real-time notifications at scale. Attendees will learn how GraphQL simplifies data access across massive datasets while maintaining performance and reliability. We'll discuss scaling patterns, monitoring strategies, and lessons learned from operating GraphQL services that handle billions of daily operations across global marketplaces. This technical deep-dive is designed for engineers interested in understanding how to architect and operate GraphQL systems at huge scale, with practical insights from Amazon's production environments.

Have you ever wished you could better understand how the entities in your graph behave over time? Are they cacheable? How often are they updated? How often are they accessed? What is the distribution of keys?

The primitives of GraphQL federation are simple: Entities with keys to uniquely identify them, distributed across multiple services.

The story they tell? It's a fascinating one, but nobody talks about it. Until now.
And it's not even that complicated, just a couple of hashes and we're able to learn more about your data than you ever thought possible.