GraphQL Query Language
GraphQL is a query language and runtime for APIs in which clients send a query describing exactly the fields they need, and the server returns JSON matching that shape. A strongly typed schema defines available data, and a single endpoint replaces many REST routes.
Technical Architecture & Deep-Dive
Facebook created GraphQL to stop mobile apps from overfetching and making many sequential calls per screen. Clients compose nested queries, and resolvers on the server fetch and assemble the requested data in one response.
GraphQL shifts complexity to the server: resolvers must be optimized to avoid N+1 query problems, and POST-based queries are harder to cache at CDNs. Many teams get most of the benefit by placing an edge BFF in front of existing REST APIs, aggregating calls and projecting only needed fields without adopting a GraphQL server.
Key Architectural Benefits
Client-Defined GraphQL Query
query MobileProfile {
user(id: "99") {
name
avatarUrl
subscription { status plan }
}
}Implement GraphQL Query Language at the Edge
Deploy lightweight API aggregation, edge caching, and secret injection in minutes without Docker containers or complex servers.
Frequently Asked Questions
Q:Can GraphQL responses be cached at the edge?
Yes, with care. Persisted queries sent over GET, or cache keys derived from a hash of the query body, allow edge caches to store GraphQL responses safely.
Q:Do I need GraphQL to avoid overfetching?
No. An edge projection or payload slimming layer can trim REST responses to the exact fields a client uses without rewriting backends.
Related Architecture Concepts
A REST API is a web interface that exposes data as resources identified by URLs and manipulated with standard HTTP methods such as GET, POST, PUT, and DELETE. Each request is stateless and responses are usually JSON, making REST the most common style for public and internal APIs.
Underfetching occurs when an API endpoint returns insufficient data for a view, requiring the frontend to initiate secondary cascading requests to retrieve related details. This creates latency waterfalls (the N+1 request problem), severely slowing down mobile and web application responsiveness.
The N+1 query problem occurs when code fetches a list of N items with one query, then makes an additional query for each item to load related data, resulting in N+1 total calls. It causes severe slowdowns in databases, GraphQL resolvers, and client-side API usage.
GraphQL federation is an architecture where multiple independent GraphQL services, called subgraphs, are composed into a single unified schema called a supergraph. A router receives client queries and plans execution across the subgraphs that own each field.
Ready-to-Use Edge Recipes
To cache linear api graphql queries at edge, put a TTL cache on your RealComposer pipeline. Cache issue list queries with stale-while-revalidate pattern. Shared edge cache absorbs repeat traffic before it reaches Linear.
Linear payloads are heavy for React Native. Pick issue id title state assignee from GraphQL response. RealComposer output mapping returns only the fields your UI needs at the edge.