GraphQL Interview Questions and Answers

GraphQL exposes a single endpoint and a typed schema rather than many resource URLs. The client sends a query describing exactly the fields it needs, so it avoids the over-fetching and under-fetching typical of fixed REST payloads. One request can traverse relationships that would take several REST round trips.

query {
  user(id: 42) { name orders(last: 3) { total } }
}

Trade-offs: HTTP caching is harder because everything is usually a POST to /graphql; the server must defend against expensive or malicious queries; and file uploads, long-running jobs and simple CRUD often map more directly to REST. REST also has richer tooling for status codes and content negotiation.

In practice GraphQL suits product UIs with varied data needs, while REST remains strong for public, cacheable, resource-oriented APIs. Many teams use both.

• Query: a read operation. Queries can run in parallel and must be side-effect free.
• Mutation: a write operation that changes server state. Top-level mutation fields run serially, so createOrder completes before chargeOrder starts, while nested selections may still resolve concurrently.
• Subscription: a long-lived stream over WebSocket or a similar transport that pushes events to the client when the server publishes them.

mutation {
  createOrder(input: { sku: "A1", qty: 2 }) { id }
}

Queries and mutations share the same schema and resolver model. A common mistake is putting writes in a query and losing the serial execution guarantee. Another is assuming mutations give transactional atomicity across fields: they are only sequential, so partial failure must be handled explicitly with error payloads or rollbacks at the service layer.

The schema is the contract between client and server: it declares the types, fields, arguments, return types and nullability that all operations are validated against. The Schema Definition Language (SDL) is the human-readable syntax for writing it.

type User {
  id: ID!
  name: String!
  email: String
  orders(first: Int = 10): [Order!]!
}

type Query {
  user(id: ID!): User
}

A ! marks a non-null field. The schema also defines input types, enums, interfaces, unions and directives. There are two authoring styles: schema-first, where SDL is the source of truth and resolvers are bound to it, and code-first, where the schema is generated from typed code. Introspection exposes the schema for tooling such as GraphiQL and code generators. Because clients build against the schema, treat it as a public contract and evolve it only with backward-compatible additions.