All 36 GraphQL quiz questions below come with a short explanation, visible right on the page — no sign-in needed. They're grouped by beginner and intermediate levels and 36 subtopics, so you can revise one part at a time. Choose Try GraphQL quiz above to take a scored run and review the questions you got wrong.
Want long-form answers? Read 40 GraphQL interview questions with answers — same topic, in more depth.
Answer: B
The client describes exactly the fields it needs and the server returns exactly that shape. REST endpoints have fixed response shapes, so the client either over-fetches or has to call multiple times.
References
Answer: D
The schema is the contract describing every type, field, and argument a client can query. Thanks to it, queries with wrong field names or types are rejected before execution, and code generation tools and editor suggestions all rely on it.
References
Answer: B
In execution, top-level fields of a mutation run sequentially so the order of data changes is deterministic, while queries are read-only so their fields can run in parallel. Semantically, a query reads and a mutation writes.
References
Answer: C
A resolver is a function that returns the value for a field. The server follows the query shape and calls the corresponding resolver for each field, so a deeply nested query triggers a call tree.
References
Answer: B
An exclamation mark means the field is never null. This is a strong commitment: if a resolver returns null for that field, the error propagates to the nearest nullable parent field, and it can wipe out an entire data branch.
References
Answer: D
Using variables keeps the query document unchanged for every value, so the server can parse and cache it, while values are type-checked. String interpolation produces a different query each time and opens the door to unintended content injection.
References
Answer: A
A fragment groups a reusable set of fields. In practice, it lets each component declare the data it needs, and then the screen composes those fragments into a single query.
References
Answer: A
Yes. The response contains both a data part and an errors part, so a query can return a partial result: the branch that fails is null and recorded in the errors list, while other branches still have normal data.
References
Answer: D
Introspection lets you query the schema itself to discover which types, fields, and arguments exist. It is the foundation for API exploration tools, query autocomplete, and automatic type generation for clients.
References
Answer: C
Under-fetching is when one screen has to call multiple endpoints and stitch the data together itself, because each endpoint only returns part of it. On mobile networks, every extra round trip makes the screen noticeably slower.
References
Answer: C
This is the N+1 problem: one call fetches the list of posts, then the author field's resolver runs separately for each post. The standard fix is to batch the calls within the same execution round into a single query.
References
Answer: A
It uses the record's type name plus identifier. That way the same object appearing in multiple queries is stored only once, and updating it in one place automatically reflects on every screen displaying it.
References
Answer: A
A cursor points to a specific position in the result set, so newly inserted records don't shift pages the way offset pagination does. The trade-off is that jumping straight to the tenth page is hard with cursors.
References
Answer: A
Put it in the business layer behind the resolver, where both the user and the specific record are known. Checking only at the entry point isn't enough, because it doesn't know whether the user is allowed to see the exact record being requested.
References
Answer: D
Because the client decides the query shape, a query nested deeply through bidirectional relationships can grow exponentially and overload the server with a single request.
References
Answer: D
The client sends a hash of the query instead of the whole document, so requests are lighter. More importantly, the server can accept only registered queries, turning that list into a barrier against arbitrary queries.
References
Answer: A
Return the record that was just changed along with its related fields, so the client can update its cache and UI immediately. With a normalized cache, just the identifier and the changed fields are enough for every screen displaying it to update itself.
References
Answer: D
Subscriptions suit unpredictable events that need to be pushed immediately: new messages, price changes, order status. For data that changes on a regular schedule, polling is usually simpler and much cheaper to operate.
References
Answer: D
GraphQL evolves by adding new fields and marking old ones as deprecated, rather than numbering versions. Old clients keep working because the old fields remain, and a field is only removed once nobody queries it anymore.
References
Answer: B
Because every query goes through a single endpoint and usually uses the POST method, intermediate caches cannot distinguish them. In return, GraphQL pushes caching to the client with normalized object caching.
References
Answer: D
Code generation produces exact types for each query, so misspelled field names or wrong types are caught at compile time. Combined with schema checks in the CI pipeline, a breaking change breaks the build instead of breaking the application.
References
Answer: A
Run real queries through the schema and compare results, since this covers the schema, resolvers, and business layer exactly as the client will encounter them. Mock the underlying data sources for fast, stable tests.
References
Answer: B
The most robust approach is to request a presigned URL via a mutation, upload the file directly to storage, then call a second mutation to attach the file to the record. The file never passes through the API server, avoiding size limits and heavy load.
References
Answer: A
Measure by query name and by per-field resolution time. Measuring at the endpoint level is meaningless because all queries share one address, and the status code is usually 200 even when the response contains errors.
References
Answer: B
GraphQL is not worth it for simple APIs with few clients and fixed data needs. The cost of the execution layer, caching, query limits, and operational observability is not offset by any clear benefit.
References
Answer: D
An interface requires every implementing type to share a common set of fields, so those fields can be queried without knowing the concrete type. A union groups types with nothing in common, so you must use per-type fragments.
References
Answer: B
A custom scalar lets you validate and normalize the format at the schema layer: invalid values are rejected before reaching the resolver, and every client receives the same format instead of each endpoint having its own.
References
Answer: A
They toggle parts of a query based on variable values, so one document can serve many cases. This matters for persisted queries, where the number of distinct documents must be kept to a minimum.
References
Answer: D
The schema handles types and requiredness, while business rules belong in the business layer. The type system cannot express rules like amounts must be positive, coupons must still be valid, or the end date must come after the start date.
References
Answer: D
Base it on the estimated query cost, not the request count. A query fetching one record and a query nested three levels deep over a thousand-element list are workloads that differ by thousands of times.
References
Answer: A
The loader caches results by key without knowing about permissions, so sharing it globally would return one user's cached data to another user's request. Creating it per request is a mandatory security boundary.
References
Answer: A
Use GET when combined with persisted queries: the URL becomes unique by hash and variables, so CDNs and intermediate caches can cache it. For long queries written inline, POST is safer because it doesn't hit URL length limits.
References
Answer: C
The client writes the expected result into the buffer immediately when sending the mutation, so the UI responds instantly. When the server replies, the real data replaces the temporary data; on failure the buffer is rolled back to its previous state.
References
Answer: B
Schema-first: write the schema in the definition language, then implement resolvers against it. Code-first: define types in code and the schema is generated. The real difference lies in the source of truth for the contract and how teams collaborate.
References
Answer: C
Use per-field resolution timing traces: they show which field takes most of the time and how many times it calls the data source, so an N+1 problem or a slow downstream service is immediately visible.
References
Answer: A
Put it in application state, not in the GraphQL buffer. The buffer is designed for server data with its own refresh and expiry mechanisms, while UI state has a completely different lifecycle.
References
Advanced goes deep on real-world scenarios and the technical pitfalls candidates actually run into. Included with Pro.
Upgrade to Pro