Performance testing in GraphQL - Mini Project: Build & Apply

GraphQL Performance Testing Basics

📖 Scenario: You are working on a GraphQL API for a bookstore. You want to test how well the API performs when querying book data.

🎯 Goal: Build a simple GraphQL query and setup to test the performance of fetching book titles and authors.

📋 What You'll Learn

Create a GraphQL schema with a Book type containing title and author fields

Add a books query that returns a list of Book items

Create a sample dataset of 3 books with exact titles and authors

Write a GraphQL query to fetch all book titles and authors

Add a configuration variable to set the number of query repetitions for performance testing

💡 Why This Matters

🌍 Real World

Performance testing GraphQL queries helps ensure your API can handle many requests quickly, which is important for user experience.

💼 Career

Understanding how to write queries and test their performance is valuable for backend developers and API engineers working with GraphQL.

1

Define the GraphQL Book type and books query

Create a GraphQL schema with a Book type that has title and author fields, both of type String!. Also add a books query that returns a list of Book items.

GraphQL

# Define the Book type and books query in the schema
# Your code here

Hint

Use type keyword to define types and String! for required string fields.

2

Add sample book data in resolver setup

Create a variable called sampleBooks that is a list of 3 book objects with exact titles and authors: { title: "1984", author: "George Orwell" }, { title: "The Hobbit", author: "J.R.R. Tolkien" }, and { title: "Fahrenheit 451", author: "Ray Bradbury" }.

GraphQL

type Book {
  title: String!
  author: String!
}

type Query {
  books: [Book!]!
}

# Create sampleBooks list with 3 book objects
# Your code here

Hint

Use an array of objects with exact keys title and author.

3

Write a GraphQL query to fetch all book titles and authors

Write a GraphQL query called GET_BOOKS that requests the title and author fields from the books query.

GraphQL

type Book {
  title: String!
  author: String!
}

type Query {
  books: [Book!]!
}

const sampleBooks = [
  { title: "1984", author: "George Orwell" },
  { title: "The Hobbit", author: "J.R.R. Tolkien" },
  { title: "Fahrenheit 451", author: "Ray Bradbury" }
];

# Write GraphQL query GET_BOOKS to fetch title and author
# Your code here

Hint

Use template string syntax with backticks and write a query requesting books with title and author.

4

Add a configuration variable for query repetitions

Create a variable called queryRepetitions and set it to 100 to specify how many times the GET_BOOKS query should be run for performance testing.

GraphQL

type Book {
  title: String!
  author: String!
}

type Query {
  books: [Book!]!
}

const sampleBooks = [
  { title: "1984", author: "George Orwell" },
  { title: "The Hobbit", author: "J.R.R. Tolkien" },
  { title: "Fahrenheit 451", author: "Ray Bradbury" }
];

const GET_BOOKS = `
  query {
    books {
      title
      author
    }
  }
`;

# Add queryRepetitions variable set to 100
# Your code here

Hint

Use const queryRepetitions = 100; to define the number of repetitions.

Practice

1. What is the main goal of performance testing in GraphQL?

easy

A. To add new fields to the schema

B. To find syntax errors in queries

C. To check how fast GraphQL queries run

D. To secure the GraphQL API from attacks

Solution

1. Step 1: Understand performance testing purpose

   Performance testing measures the speed and responsiveness of queries.

2. Step 2: Identify the main goal in context

   It helps find slow queries and improve user experience by checking query speed.

3. Final Answer:

   To check how fast GraphQL queries run -> Option C

4. Quick Check:

   Performance testing = check query speed [OK]

Hint: Performance testing = measuring query speed [OK]

Common Mistakes:

• Confusing performance testing with syntax checking
• Thinking it adds schema fields
• Mixing it with security testing

2. Which of the following is a correct way to measure GraphQL query performance?

easy

A. Use a tool to record query execution time

B. Add more fields to the query

C. Change the query syntax randomly

D. Ignore slow queries

Solution

1. Step 1: Identify valid performance measurement method

   Measuring execution time with tools is standard for performance testing.

2. Step 2: Eliminate incorrect options

   Adding fields, changing syntax randomly, or ignoring slow queries do not measure performance.

3. Final Answer:

   Use a tool to record query execution time -> Option A

4. Quick Check:

   Measure time with tools = correct [OK]

Hint: Measure query time with tools, not by changing queries [OK]

Common Mistakes:

• Thinking adding fields improves performance
• Trying random syntax changes to test speed
• Ignoring slow queries instead of measuring

3. Given this GraphQL query performance log:
{ query: "{ user { id name posts { title } } }", timeMs: 120 }
What does the timeMs value represent?

medium

A. The time taken to execute the query in milliseconds

B. The size of the response in bytes

C. The number of users returned

D. The number of fields requested

Solution

1. Step 1: Understand the log fields

   The log shows query and timeMs, which usually means execution time in milliseconds.

2. Step 2: Match timeMs meaning

   timeMs is the time taken to run the query, not count of fields, users, or size.

3. Final Answer:

   The time taken to execute the query in milliseconds -> Option A

4. Quick Check:

   timeMs = execution time in ms [OK]

Hint: timeMs always means execution time in milliseconds [OK]

Common Mistakes:

• Confusing timeMs with field count
• Thinking timeMs is response size
• Assuming timeMs counts returned items

4. You wrote a script to measure GraphQL query times but it always shows zero milliseconds. What is the most likely problem?

medium

A. The schema is missing

B. The queries are too slow

C. GraphQL does not support timing

D. The script is not measuring time correctly

Solution

1. Step 1: Analyze the symptom

   Always zero milliseconds means no real timing is captured.

2. Step 2: Identify likely cause

   The script likely has a bug or uses wrong timing method, not that queries are slow or schema missing.

3. Final Answer:

   The script is not measuring time correctly -> Option D

4. Quick Check:

   Zero time means measurement error [OK]

Hint: Zero time usually means timing code bug [OK]

Common Mistakes:

• Assuming queries are too slow for zero time
• Thinking GraphQL cannot be timed
• Blaming schema absence for timing issues

5. You want to improve a slow GraphQL query that fetches a user and all their posts with comments. Which approach best improves performance?

hard

A. Add more nested fields to the query

B. Use query batching or caching to reduce repeated data fetching

C. Remove all comments from the schema

D. Rewrite the query to fetch all users instead

Solution

1. Step 1: Understand the slow query cause

   Fetching nested data like posts and comments can be slow due to many database calls.

2. Step 2: Identify best optimization

   Using batching or caching reduces repeated calls and speeds up queries.

3. Step 3: Eliminate wrong options

   Adding fields increases load, removing comments breaks schema, fetching all users is unrelated.

4. Final Answer:

   Use query batching or caching to reduce repeated data fetching -> Option B

5. Quick Check:

   Batching/caching speeds nested queries [OK]

Hint: Batch or cache nested queries to improve speed [OK]

Common Mistakes:

• Adding more fields thinking it helps
• Removing schema parts breaks API
• Fetching unrelated data wastes resources