Apollo Tech Notes

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

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

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

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

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

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

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

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

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.

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.

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

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

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.

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.

The Apollo 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 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.

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

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

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

Sending Apollo 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.

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

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

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.

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

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

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

Considerations for load testing with GraphQL in the Apollo ecosystem.

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

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

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

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

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

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

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

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

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