26. What causes the N+1 problem in nested GraphQL fields?

Independent nested field resolvers can each request related data separately. Without batching, a list of parent objects can therefore generate one related-data query per parent.

27. Why should DataLoader normally be request-scoped?

Request scoping prevents cached values from one user's operation being reused in another user's operation and keeps batching aligned with a single GraphQL execution.

28. Why must a DataLoader batch function preserve key order?

The loader associates returned values with requested keys positionally. Therefore, the batch function must return a result corresponding to every input key in the same order.

29. What happens when a non-null GraphQL field resolver fails?

GraphQL propagates null upward through non-null parent fields until it reaches a nullable boundary or the response root, while reporting the error.

30. Can GraphQL return both data and errors?

Yes. A GraphQL response can contain partial data together with an errors array when some fields fail while others succeed.

31. Why is nullability an architectural decision?

Nullability determines how failures propagate through the response tree. Making a field non-null can cause failures to remove larger portions of the response.

32. What is query complexity analysis?

It estimates the resource cost of a GraphQL operation and can reject operations that exceed an allowed complexity threshold.

33. Why is query depth limiting insufficient by itself?

Depth measures nesting but not necessarily actual resource cost. A shallow field can still execute an extremely expensive database query.

34. How can GraphQL APIs prevent clients from requesting unlimited data?

They can enforce pagination, maximum page sizes, query complexity limits, depth limits, rate limits, and persisted operations.

35. What is optimistic UI?

Optimistic UI updates the client interface before the server confirms a mutation, assuming the operation will succeed and rolling back if it fails.

36. What is normalized caching?

Normalized caching stores entities independently under stable identifiers so that updates to an entity can affect multiple cached query results.

37. Why can GraphQL subscriptions require distributed infrastructure?

When multiple server instances exist, an event published on one instance may need to reach clients connected to another instance. A shared event system can distribute those events.

38. How should GraphQL errors be handled in production?

Expected business errors should have stable, safe representations, while unexpected internal details should be logged server-side without exposing sensitive implementation information to clients.

39. How can GraphQL schema changes remain backward compatible?

Prefer additive changes, deprecate old fields, migrate clients, monitor usage, and remove deprecated fields only after confirming they are no longer needed.

40. What is the difference between schema-first and code-first GraphQL?

Schema-first explicitly defines the GraphQL contract and implements code against it, while code-first constructs the schema from application code and types.