Introduction

The GraphQL Schema is the foundation of every GraphQL API. It defines the API contract between clients and the server by describing the available data, operations, and relationships. Unlike REST, where endpoint documentation is often maintained separately, the GraphQL schema itself acts as a strongly typed contract that clients can introspect.

GraphQL provides a rich type system that includes scalar types, object types, enums, interfaces, unions, input types, lists, and non-null types. Together, these types enable APIs to be expressive, predictable, and self-documenting.

Spring Boot, through Spring for GraphQL, uses these schema definitions to map GraphQL operations to Java code, making schema-first development the preferred approach for enterprise applications.

---

What You'll Learn

• GraphQL Schema
• Type System
• Object Types
• Scalar Types
• Input Types
• Enums
• Interfaces
• Unions
• Custom Scalars
• Spring Boot Integration

---

GraphQL Schema Architecture

            GraphQL Client
                   │
                   ▼
            GraphQL Schema
                   │
      ┌────────────┼────────────┐
      ▼            ▼            ▼
   Queries     Mutations   Subscriptions
      │            │            │
      ▼            ▼            ▼
  Object Types  Input Types  Scalars
                   │
                   ▼
             Java Resolvers
                   │
                   ▼
          Database / Services

---

Schema Execution Flow

Client Request

↓

Schema Validation

↓

Type Validation

↓

Resolver Execution

↓

Business Logic

↓

Response Validation

↓

JSON Response

---

1. What is a GraphQL Schema?

Answer

A GraphQL schema defines the structure and capabilities of a GraphQL API.

It specifies:

• Queries
• Mutations
• Subscriptions
• Object types
• Input types
• Relationships
• Scalars
• Enums

Example

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

The schema serves as the contract between API providers and consumers.

---

2. Why is the GraphQL Schema Important?

Answer

The schema provides:

• Strong typing
• Automatic documentation
• Validation
• Discoverability
• Tooling support
• Client code generation
• API consistency

Because the schema is machine-readable, tools can automatically generate documentation and client SDKs.

---

3. What are Object Types?

Answer

Object types represent the primary business entities returned by GraphQL.

Example

type User {
    id: ID!
    name: String!
    email: String!
}

Each field has its own type, making GraphQL APIs strongly typed and predictable.

---

4. What are Scalar Types?

Answer

Scalars represent primitive values.

Built-in scalar types include:

Scalar	Description
Int	Integer
Float	Decimal number
String	Text
Boolean	True or False
ID	Unique identifier

Example

type Product {
    id: ID!
    price: Float!
    available: Boolean!
}

---

5. What are Non-Null Types?

Answer

The exclamation mark (!) indicates that a field cannot be null.

Example

type Employee {
    id: ID!
    name: String!
}

Here, both id and name are mandatory.

Benefits:

• Stronger contracts
• Better validation
• Reduced null handling
• Improved client confidence

---

6. What are List Types?

Answer

Lists represent collections of values.

Example

type Query {
    users: [User]
}

A non-null list of non-null users:

users: [User!]!

This means:

• The list cannot be null.
• Each user inside the list cannot be null.

---

7. What are Input Types?

Answer

Input types are used for supplying data to mutations.

Example

input CreateUserInput {
    name: String!
    email: String!
}

Mutation

type Mutation {
    createUser(input: CreateUserInput!): User
}

Input types separate request models from response models.

---

8. What are Enum Types?

Answer

Enums define a fixed set of valid values.

Example

enum OrderStatus {
    NEW
    PAID
    SHIPPED
    DELIVERED
}

Benefits:

• Better validation
• Reduced errors
• Strong typing
• Improved readability

---

9. What are Interfaces?

Answer

Interfaces define common fields shared by multiple object types.

Example

interface Person {
    id: ID!
    name: String!
}

Implementations

type Employee implements Person {
    id: ID!
    name: String!
    department: String!
}

type Customer implements Person {
    id: ID!
    name: String!
    loyaltyPoints: Int!
}

Interfaces encourage schema reuse and polymorphism.

---

10. What are Union Types?

Answer

Union types allow a field to return one of several object types.

Example

union SearchResult = User | Product

A search API can return either a User or a Product without requiring a shared parent type.

---

11. What are Custom Scalars?

Answer

Custom scalars represent domain-specific primitive values.

Examples:

• Date
• DateTime
• UUID
• URL
• Email
• Currency

Example

scalar DateTime

Custom scalars improve validation and expressiveness.

---

12. How Does Spring Boot Support GraphQL Schemas?

Answer

Spring Boot uses Spring for GraphQL with schema-first development.

Typical project structure

src/main/resources/graphql/

schema.graphqls

Example resolver

@QueryMapping
public User user(@Argument Long id) {
    return service.findById(id);
}

Spring automatically maps GraphQL schema definitions to Java resolver methods.

---

13. What are Common Schema Design Mistakes?

Answer

Common mistakes include:

• Poor naming conventions
• Deeply nested object graphs
• Excessive nullable fields
• Duplicated types
• Missing enums
• Overusing custom scalars
• Mixing input and output models
• Weak documentation
• Breaking schema changes
• Ignoring backward compatibility

---

14. What are Enterprise Schema Design Best Practices?

Answer

Recommended practices:

• Use meaningful type names
• Keep schemas modular
• Prefer enums over strings
• Use input types for mutations
• Minimize nullable fields
• Design reusable interfaces
• Version responsibly
• Document types
• Validate schema changes
• Maintain backward compatibility

These practices keep schemas clean and maintainable as APIs evolve.

---

15. What Does an Enterprise GraphQL Schema Architecture Look Like?

Answer

                GraphQL Schema
                      │
      ┌───────────────┼────────────────┐
      ▼               ▼                ▼
   Query Type     Mutation Type   Subscription Type
      │               │                │
      ▼               ▼                ▼
 Object Types    Input Types      Event Types
      │               │
      ├───────┬───────┤
      ▼       ▼       ▼
 Scalars   Enums   Interfaces
              │
              ▼
         Union Types
              │
              ▼
      Spring Boot Resolvers
              │
              ▼
 Database • REST APIs • Kafka

Enterprise Components

• Schema Registry
• Query Types
• Mutation Types
• Subscription Types
• Object Types
• Input Types
• Custom Scalars
• Enums
• Interfaces
• Union Types
• Spring Boot Resolvers
• GraphQL Gateway

---

GraphQL Schema and Types Summary

Component	Purpose
Schema	API contract
Object Type	Business entity
Scalar	Primitive value
Input Type	Mutation input
Enum	Fixed values
Interface	Shared contract
Union	Multiple return types
List	Collection of values
Non-Null	Mandatory field
Custom Scalar	Domain-specific primitive

---

Interview Tips

1. Explain that the GraphQL schema is the authoritative contract between clients and the server.
2. Differentiate object types, input types, scalar types, enums, interfaces, and unions with examples.
3. Explain the meaning of ! (non-null) and list types such as [User!]!.
4. Recommend using enums instead of strings wherever possible for stronger validation.
5. Discuss why input types should be separate from output object types.
6. Explain how interfaces promote reuse and unions support polymorphic responses.
7. Mention custom scalars for values such as dates, UUIDs, and currency.
8. Describe schema-first development using Spring for GraphQL.
9. Highlight backward compatibility when evolving schemas in production.
10. Use enterprise examples involving users, orders, products, and payments to demonstrate schema design.

---

Key Takeaways

• The GraphQL schema defines the complete API contract and is central to schema-first development.
• GraphQL's type system includes object types, scalars, lists, non-null types, input types, enums, interfaces, unions, and custom scalars.
• Strong typing enables validation, automatic documentation, and client code generation.
• Input types should be used for mutations, while object types represent response models.
• Interfaces and unions support reusable and flexible schema design.
• Custom scalars improve validation for domain-specific values such as dates and UUIDs.
• Spring Boot integrates seamlessly with GraphQL schemas through Spring for GraphQL and schema-first development.
• Clean naming, modular schemas, and backward compatibility are essential for enterprise GraphQL APIs.
• A well-designed schema improves maintainability, discoverability, and developer productivity.
• GraphQL Schema and Types is a core interview topic for Java, Spring Boot, GraphQL, Microservices, Cloud, and Solution Architect roles.