roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Answer GraphQL interview questions about the protocol itself, not just one library's API. Covers the type system, execution and resolvers, batching, caching, pagination, security, and federation.
912 of 912 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 912 new. 0 cut, outside your plan.
A GraphQL question usually arrives inside another round, let in by a line on the CV or the team's stack: the technical conversation of a backend or frontend loop, or a system design brief that puts several clients in front of many services and asks whether one graph across them is worth its cost. Teams running it in production give it more room, often starting from a schema you sketch for a small domain.
The questions are built on a schema and a query. Posts with their authors' names: how many database calls, and what does a DataLoader change? A non-null field whose resolver throws: what turns null, and how does data itself end up null? Why does one POST endpoint answering everything with a 200 lose the CDN, and how do persisted queries win it back? How do a hundred aliases of a login mutation pass a limiter that counts requests? Why does a list stay stale after a mutation whose result the normalized cache stored correctly?
Explaining what happens is the floor. Above it, interviewers listen for who should own the problem and what the fix costs: batching against a join planned from the selection set, nullable fields that survive a failing backend against types that tell clients the truth, persisted documents against an open endpoint, a federated graph against one server with one schema owner.
Most of what GraphQL is asked about is a departure from HTTP, which is why HTTP leads the plan. One endpoint, usually behind POST, gives up what caching and conditional requests hand a REST API for free, and a 200 carrying an errors array no longer reports the outcome; neither trade can be explained without the thing traded away.
The protocol module is the core, and its inner order is an argument: types, then the documents clients send, then execution, the per-field resolver model from which N+1 fetching and null propagation both follow. Its later sections are what running one graph in public adds on top.
The specification defines subscriptions but not the wire they travel on, so transports come next: WebSockets, under two incompatible subprotocols with confusingly similar names, and Server-Sent Events where a one-way stream is enough. They lead into security, since a browser cannot set an Authorization header on a WebSocket handshake and the token usually rides in the first message instead. With one endpoint, authorization moves from the route into each field's resolver; JWT and OAuth2 then supply the identity those resolvers read from the request context.
Only then does the plan name libraries. Spring for GraphQL and HotChocolate on .NET are the protocol module seen through a framework: a @BatchMapping method is a DataLoader with the wiring done for you, and interviewers expect you to see the mechanism under the annotation. Client libraries close the plan, because a client cache is the protocol's object identity put to work: Apollo normalizes responses into records keyed by type name and id, Relay compiles fragments colocated with components and gave the ecosystem its cursor connection convention, and urql starts from a simpler document cache with normalization as an opt-in exchange.
Start from your side of the wire. A backend engineer takes HTTP, the protocol and security stretches, then the one server library their stack uses, and leaves the client modules for last. A frontend engineer needs the same protocol module and the transports, then Apollo or Relay in depth, where client questions about caches and fragments live. Since each reader skips a different end of the plan, switch study order to by topics: it keeps every module whole, so the end you skip drops out cleanly instead of leaving its questions scattered through the rest. The junior bar is reading a query against [a schema](/topics/proto-graphql-schema-sdl) and naming what each resolver is handed; hold that firmly before going further. Seniors get the most from caching, abuse control, schema evolution and federation, where the design conversation goes. With only days, the protocol module alone, with importance narrowed to must know, repays the time better than a thin pass over everything. GraphQL appears here as one API style, not beside the others: REST resource design, gRPC and OpenAPI contracts have no module, though a design round often asks why a graph rather than one of them. The [API Design roadmap](/roadmaps/api-design) takes up those styles and the choice between them.
Start from your side of the wire. A backend engineer takes HTTP, the protocol and security stretches, then the one server library their stack uses, and leaves the client modules for last. A frontend engineer needs the same protocol module and the transports, then Apollo or Relay in depth, where client questions about caches and fragments live. Since each reader skips a different end of the plan, switch study order to by topics: it keeps every module whole, so the end you skip drops out cleanly instead of leaving its questions scattered through the rest.
The junior bar is reading a query against a schema and naming what each resolver is handed; hold that firmly before going further. Seniors get the most from caching, abuse control, schema evolution and federation, where the design conversation goes. With only days, the protocol module alone, with importance narrowed to must know, repays the time better than a thin pass over everything.
GraphQL appears here as one API style, not beside the others: REST resource design, gRPC and OpenAPI contracts have no module, though a design round often asks why a graph rather than one of them. The API Design roadmap takes up those styles and the choice between them.