Apollo Tech Notes

Learn how to designate entity ownership and make "entity extension" a first-class concept in your Apollo Federation 2 supergraph.

Avoiding props-drilling by making data accessible through a React Hook, which can be called anywhere in the nested component tree.

Learn naming and casing conventions for GraphQL schema types, fields, and arguments and how to enforce them with GraphOS.

Convert operation traces into aggregated metrics using OpenTelemetry Collector and Prometheus for a broader view of your graph's performance.

Improve GraphQL operation monitoring by tagging operations with with client details. See code examples for Apollo Router and Apollo Server.

Combine authorization and authentication strategies with the Apollo Router to secure your graph through defense in depth.

Implement GraphQL server overload protection for high traffic scenarios to ensure availability and reduce error rates.

Use this checklist—covering the Apollo Router, subgraphs, and clients—to identify potential gaps before your graph handles production traffic.

Learn different response type patterns for GraphQL queries and mutations.

Recommendations for improving your gateway's performance when using Apollo Server with the @apollo/gateway library.

Use advanced cache eviction patterns with custom cache keys to selectively evict cached responses when relevant events occur.

Organize root-level operation fields into namespaces to improve the logical structure to your GraphQL schema.

Sending Apollo Router traces and metrics to APM tools to gain insight into your graph's performance and stability.

A step-by-step guide for migrating from a GraphQL monolith to a federated supergraph with Apollo Federation.

Learn how contracts enable teams to contribute to a single unified graph and also deliver use-case-specific schemas to different consumers.

Recommendations and considerations for determining the correct resource requests and limits for application pods in a Kubernetes system.

Interfaces enable schema fields to return one of multiple object types. Explore examples and avoid common pitfalls in using interfaces.

If product requirements don't align with a single domain, it may suggest the need for a new domain or subgraph.

Learn how to handle the "N+1 query problem" for operations that return a list in a federated graph.

Learn shortcomings and solutions for GraphQL adoption patterns and anti-patterns, including monoliths, BFFs.queries a single GraphQL server.

Mock parts of your supergraph as you develop both your subgraphs and clients to enable teams to work in parallel without blocking each other.

Best practices for securing federated GraphQL APIs, including limiting discoverability, error obfuscation, query depth limits, and more.

Gracefully manage GraphQL type and field deprecations by using field metrics and the @deprecated type system directive.

Strong stewardship practices maintain a supergraph's integrity while simultaneously driving its adoption across teams.

Schema design best practices for entities, including when to define, reference and extend entities.

Recommendations and considerations for minimizing build time when using custom Apollo Router builds.

Support GraphQL client applications that consume data from our federated graph by designing schemas in an abstract, demand-oriented way.

Use tools like GraphOS Studio, Rover, and contracts to ensure smooth releases and minimize client impact.

Common questions around Relay's Connections specification and how to use it wih Apollo Federation.

The purpose of this technote is to demonstrate queries/mutations for identifying an actor attempting to use the graph.

Server-driven UI is an architectural pattern that aims to reduce client-side logic and provide consistency across client platforms.

Explore SDUI UI patterns to structure your graph's schema for encoding and representing UI elements, using enums, contracts, and interfaces.

Considerations for load testing with GraphQL in the Apollo ecosystem.

The Apollo Router isn't based on URLs or REST endpoints, its a GraphQL-native solution to handle your clients API operations.

Apollo's recommendations and best practices for keeping client apps up-to-date with supergraph schema changes.

Federation orchestrates mutation fields but additional considerations are necessary when handling state changes across distributed systems.

Log query plans and subgraph calls with the Apollo Router and @apollo/gateway to help debug problematic queries.

Union types can represent multiple types of data in a single field and can help you handle GraphQL responses with clarity and flexibility.

Use a component registry and design systems and tokens to simplify client logic with SDUI.

Avoid BFF sprawl by using GraphQL as an abstraction between service consumers and backend services.

Estimate the system resources you need to allocate for the Apollo Router to run production traffic.

Most organizations adopting GraphQL use both for different purposes and at different layers of the stack.

Learn CI/CD best practices and examples when using graph variants for multiple deployment environments.

Enable HTTP multipart subscriptions when using an API gateway in front of the router.

Test your GraphQL architecture comprehensively with unit, integration, end-to-end, composition, and component and operation testing.

Weigh the implications of choices about nullability for every GraphQL type, field, and argument in a schema.