SECTION 2 – Schema Design & Types (Q11–Q25)

Q11. What are Scalar Types in GraphQL and why are they important?

Explanation:
Scalar types represent primitive values that cannot be broken into smaller fields. GraphQL provides default scalars such as Int, Float, String, Boolean, and ID. These form the foundation of every schema. Scalars ensure data consistency and validation at API level. In enterprise systems, scalars prevent invalid client inputs before hitting business logic. Custom scalars can also be created for Date, Email, or Phone.

Syntax:

age: Int
name: String

Example:

type User {
  id: ID!
  name: String
  age: Int
}

Interview Tip:
Always mention default + custom scalars.

Q12. What are Custom Scalars and when should they be used?

Explanation:
Custom scalars allow you to define your own primitive types such as Date, URL, or Email. They are useful when built-in scalars are not enough. Validation logic lives inside the scalar resolver. Large companies use custom scalars to standardize formats across microservices. This avoids repeated validation in every resolver.

Syntax:

scalar Date

Example:

scalar Date

type User {
  createdAt: Date
}

Interview Tip:
Use custom scalars for validation and consistency.

Q13. What are Enums in GraphQL?

Explanation:
Enums restrict field values to a predefined list. This prevents invalid input from clients. Enums improve readability and documentation. Enterprise APIs use enums for roles, statuses, and categories. They act like constants shared between frontend and backend.

Syntax:

enum Role { ADMIN USER }

Example:

type User {
  role: Role
}

Interview Tip:
Enums enforce allowed values.

Q14. What are Input Types and why are they needed?

Explanation:
Input types define structured data for mutations. GraphQL does not allow object types as inputs, so Input types are required. They improve validation and maintain clean APIs. In production systems, input types act as DTOs (Data Transfer Objects). They also simplify versioning.

Syntax:

input UserInput { name: String }

Example:

mutation createUser($data: UserInput!)

Interview Tip:
Inputs are mandatory for complex mutations.

Q15. What is Non-Null (!) operator?

Explanation:
The exclamation mark makes a field mandatory. It guarantees that value will never be null. If server fails to return it, GraphQL throws error. This improves contract reliability. Enterprises use Non-Null to enforce critical fields like IDs.

Syntax:

id: ID!

Example:

type User { id: ID! }

Interview Tip:
Non-null strengthens API contracts.

Q16. What are Lists in GraphQL?

Explanation:
Lists represent collections of items. They are written using square brackets. Lists can also be combined with Non-Null for strict rules. Companies use lists for pagination and relationships. Understanding list nullability is critical in interviews.

Syntax:

users: [User]

Example:

type Query { users: [User!]! }

Interview Tip:
Explain list + nullability.

Q17. What are Interfaces in GraphQL?

Explanation:
Interfaces define common fields shared by multiple types. They support polymorphism. This is useful when different objects have similar structure. Enterprise APIs use interfaces for search results or activity feeds.

Syntax:

interface Node { id: ID! }

Example:

type User implements Node { id: ID! name: String }

Interview Tip:
Interfaces enable polymorphism.

Q18. What are Unions in GraphQL?

Explanation:
Unions allow a field to return multiple unrelated types. Unlike interfaces, unions share no common fields. They are commonly used in search APIs. Clients must use fragments to handle responses.

Syntax:

union SearchResult = User | Post

Example:

search(text:String): [SearchResult]

Interview Tip:
Union = multiple types, no shared fields.

Q19. What are Fragments and why are they useful?

Explanation:
Fragments allow reuse of field selections. They reduce duplication and improve maintainability. Frontend teams rely heavily on fragments. Enterprises use fragments to standardize UI queries.

Syntax:

fragment UserFields on User

Example:

fragment UserFields on User { id name }

Interview Tip:
Fragments = reusable query parts.

Q20. What are Query Variables?

Explanation:
Variables allow dynamic values in queries. They improve security and caching. Instead of hardcoding IDs, variables are passed separately. Production APIs always use variables.

Syntax:

query ($id:ID!)

Example:

query GetUser($id:ID!) { getUser(id:$id){name} }

Interview Tip:
Variables prevent query injection.

Q21. What are Aliases?

Explanation:
Aliases rename fields in response. They allow same field to be queried multiple times. Used heavily in dashboards. Prevents naming collisions.

Example:

user1:getUser(id:"1")

Interview Tip:
Aliases rename response fields.

Q22. What are Directives?

Explanation:
Directives modify query execution. Common directives are @include and @skip. They add conditional logic at query level. Enterprises use directives for feature flags.

Syntax:

@include(if:true)

Interview Tip:
Directives control execution flow.

Q23. How does pagination work in GraphQL?

Explanation:
Pagination limits large datasets. Offset or cursor based methods are used. Cursor pagination is preferred in production. It improves performance and consistency.

Interview Tip:
Cursor pagination is best practice.

Q24. How are relationships modeled in GraphQL?

Explanation:
Relations are defined via nested types. Parent resolver fetches child data. DataLoader is used to avoid N+1 problem. Enterprises rely on this pattern.

Interview Tip:
Mention N+1 prevention.

Q25. What is Schema-first vs Code-first?

Explanation:
Schema-first writes schema first. Code-first generates schema from code. Both are used in companies. Schema-first preferred for large teams.

Interview Tip:
Big companies favor schema-first.