Apollo Tech Notes

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 GraphOS Router and Apollo Server.

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

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

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

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

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

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

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

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

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

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

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

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

Considerations for load testing with GraphQL in the Apollo ecosystem.

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

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

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

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

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

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

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.

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

Learn different response type patterns for GraphQL queries and mutations.

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

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

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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