GraphQLConf 2026

GraphQL simplifies client development through flexible, expressive data queries. However, in serverless production environments, that flexibility can quietly increase latency and infrastructure cost.

In AWS-based architectures using Lambda, DynamoDB, Aurora Serverless, and distributed services, resolver design and query structure directly impact execution time, cold starts, and overall spend. Unlike REST, GraphQL shifts cost dynamics to query complexity and resolver fan-out, and often in ways teams don’t anticipate until production traffic scales.

This session examines common performance and cost anti-patterns in serverless GraphQL systems, including N+1 resolver cascades, unbounded query depth, over-fetching, and inefficient resolver fan-out. We’ll explore how these patterns affect Lambda duration, concurrency, and downstream data stores.

Attendees will learn practical mitigation strategies such as batching with DataLoader, caching and persisted queries, query complexity limits, schema guardrails, and observability techniques to detect bottlenecks early.

Use Apollo Client v4 in React with Tanstack Router.

We’ll be using GraphQL code generation from your schema, preloading data at the router level, optmistic updates, and using Apollo’s cache to eliminate unnecessary refetching and rerenders. You’ll see how smart cache usage and colocating queries lets components read data directly where they need it which will reduce prop drilling. The goal is to show how “modern” Apollo Client patterns fit naturally into today’s React architecture to create apps that feel both simpler to reason about and noticeably more performant.

Retirement data is surprisingly complicated, from provisions to participant payroll data to plan sponsor's unique needs. This presents a complicated and heavy requirement to fetch data points that provide the value, and regulatory requirements, that third party administrators require. GraphQL provides this, it allows specific data to be fetched at each stage of the plan lifecycle, without requiring us to fetch all of the data that we have. This allowed our platform to decrease latency by 30%, load time by 1 second, and server load by 50%.

Abstract: Schema governance shouldn’t grind development to a halt or burn out graph stewardship teams. As Intuit’s Supergraph ecosystem grew, our reliance on manual schema reviews created bottlenecks that slowed onboarding and frustrated developers. We knew we needed a better approach — so we built a hybrid governance model that puts Schema Co-Pilot directly into the developer workflow and transformed our "API Jedis" from gatekeepers into enablers.

In this talk, you’ll learn how we built real-time IDE linting, AI-powered schema analysis, and semantic “collision” detection to surface issues before code is even committed. With these tools in place, onboarding timelines shrank from weeks to days, and contributors now ship to the graph with speed and confidence.

Who should attend: Platform engineers, API architects, and engineering leaders responsible for GraphQL governance and developer experience.

Key takeaway: Governance isn’t about gatekeeping — it’s about building smart tools that help your teams move faster with confidence.

Viaduct, Airbnb's unified data access layer, hosts over 1.5M lines of application code from 500+ tenants, with 200+ changes merged daily—all operating as a single service. At this scale, enabling teams to independently monitor and troubleshoot their code is essential.
This talk describes how we approach observability with multitenancy at the core:
- Establishing clear ownership of modules and attributing metrics, spans, and errors to those owners
- Providing alerts and dashboards at multiple levels: system, operation, tenant, and field
- Enabling schema-driven alerting, where tenants declaratively specify monitoring requirements directly in the schema and the platform implements them automatically
- Using execution traces to visualize query execution and core-tenant interactions, tackling challenges like:
- Representing batched dataloader calls (where N field requests become 1 RPC)
- Instrumenting downstream service clients across all data-fetching code
- Managing observability costs via selective sampling and cardinality-aware metrics

Our goal: empower tenants to manage their portion of Viaduct as a standalone service—without bottlenecking on the platform team.

When we give AI agents access to our GraphQL APIs, we introduce a new class of distributed system challenges: non-deterministic queries, potential N+1 floods, and authorization bypasses. How do we ensure our "AI-generated" queries are safe and efficient?

This talk bridges the gap between AI Quality Engineering and GraphQL governance. Building on my work designing evaluation frameworks for multi-agent systems, I will present strategies for monitoring and governing agents that interact with GraphQL endpoints. We will discuss how to implement "Semantic Rate Limiting" (analyzing query complexity vs. user intent) and how to evaluate the accuracy of agent-generated GraphQL syntax using "LLM-as-a-Judge" frameworks.

We will also cover the "Human-in-the-Loop" aspect: using GraphQL subscriptions to stream agent reasoning to human supervisors for real-time validation before a mutation is executed. Attendees will learn how to open their Graphs to AI without compromising on security or performance reliability.

You know how to build client apps—but where do client developers fit in the new world of ChatGPT and MCP? If you've used GraphQL before, it turns out your knowledge translates directly. This talk demonstrates how to build MCP apps using Apollo's AI apps client and MCP server with patterns you already use:
1. Fragment colocation → Tool design: Structure MCP tools like component data requirements
2. Query optimization → Tool call patterns: Minimize LLM roundtrips with the same performance thinking
3. Type safety → Tool schemas: Apply GraphQL's type discipline to MCP definitions
A live demo builds an MCP app querying a GraphQL API, showing how best practices from GraphQL client development apply to OpenAI and MCP apps.

Wayfair is embedding AI and MCP into every stage of the developer workflow to unlock speed without compromising quality. From Schema Copilot (inline reviews) to AI Mocking (intelligent test data generation) to AI-Assisted Schema Documentation (auditing and auto-generating descriptions across 200+ subgraphs), these purpose-built tools streamline workflows, reduce friction, and scale engineering excellence—helping teams ship faster with greater confidence and consistency. Join to learn how AI and MCP cut busywork so Wayfair’s devs can ship faster with confidence.

We built a real-time system for Postgres→React sync using a `LISTEN/NOTIFY` Postgres trigger, GraphQL `@live` queries, a React hook and a custom ORM-inspired GraphQL query builder. Starting from ESP32 microcontroller devices sending MQTT messages and a Node/Postgres backend, we moved from polling to a stand-alone PoC with Yoga, Prisma triggers, and a custom `useLiveQuery` hook. After proving that the PoC was working we integrated with all our existing full-stack apps. So now we have low-latency UI updates, reusable cross-app logic, and easier extension for new sensor values. Great UX and excellent DX.

TOC

- Title & minimal intro
- Goals (What We Needed)
- Existing System (What We Had)
- Attempts & Why They Failed
- Solution Overview
- Postgres `LISTEN/NOTIFY`
- `useLiveQuery` React hook
- Yoga and Apollo `@live` integration
- GraphQL query builder
- GraphQL SDL generator
- GraphQL resolver generator
- Demo / Results
- Tradeoffs, Lessons & Next Steps
- Q&A