N+1 problem and solutions in GraphQL - Mini Project: Build & Apply

Understanding and Solving the N+1 Problem in GraphQL

📖 Scenario: You are building a simple GraphQL API for a blog. The blog has authors and posts. Each author can have many posts. You want to fetch authors and their posts efficiently.

🎯 Goal: Build a GraphQL query and resolver setup that avoids the N+1 problem by batching database requests.

📋 What You'll Learn

Create a list of authors with their IDs and names

Create a list of posts with author IDs and titles

Add a helper to batch fetch posts by author IDs

Write a GraphQL resolver that uses the batch helper to fetch posts for multiple authors at once

💡 Why This Matters

🌍 Real World

In real apps, fetching related data inefficiently causes slow responses. Batching queries improves performance.

💼 Career

Backend developers and GraphQL engineers must understand and solve the N+1 problem to build fast APIs.

1

DATA SETUP: Create authors and posts data

Create a list called authors with these exact entries: {"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}. Also create a list called posts with these exact entries: {"id": 1, "authorId": 1, "title": "Post A"}, {"id": 2, "authorId": 1, "title": "Post B"}, {"id": 3, "authorId": 2, "title": "Post C"}.

GraphQL

# Your code here

Hint

Use Python lists of dictionaries to represent authors and posts with exact keys and values.

2

CONFIGURATION: Create a batch function to get posts by author IDs

Create a function called get_posts_by_author_ids that takes a list author_ids and returns a dictionary mapping each author ID to a list of their posts from the posts list.

GraphQL

authors = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"}
]

posts = [
    {"id": 1, "authorId": 1, "title": "Post A"},
    {"id": 2, "authorId": 1, "title": "Post B"},
    {"id": 3, "authorId": 2, "title": "Post C"}
]

def get_posts_by_author_ids(author_ids):
    # Your code here

Hint

Use a dictionary comprehension to create empty lists for each author ID, then loop through posts to add them to the right list.

3

CORE LOGIC: Write a resolver to fetch authors with their posts using batch function

Create a function called resolve_authors_with_posts that returns a list of authors where each author dictionary has a new key posts containing their posts. Use get_posts_by_author_ids to fetch posts for all authors at once.

GraphQL

authors = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"}
]

posts = [
    {"id": 1, "authorId": 1, "title": "Post A"},
    {"id": 2, "authorId": 1, "title": "Post B"},
    {"id": 3, "authorId": 2, "title": "Post C"}
]

def get_posts_by_author_ids(author_ids):
    result = {author_id: [] for author_id in author_ids}
    for post in posts:
        if post["authorId"] in author_ids:
            result[post["authorId"]].append(post)
    return result

def resolve_authors_with_posts():
    # Your code here

Hint

First get all author IDs, then get posts for all authors at once, then add posts to each author dictionary.

4

COMPLETION: Define a GraphQL schema snippet for authors and posts

Write a GraphQL schema snippet defining types Author and Post. Author should have fields id (ID!), name (String!), and posts ([Post!]!). Post should have fields id (ID!) and title (String!).

GraphQL

authors = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"}
]

posts = [
    {"id": 1, "authorId": 1, "title": "Post A"},
    {"id": 2, "authorId": 1, "title": "Post B"},
    {"id": 3, "authorId": 2, "title": "Post C"}
]

def get_posts_by_author_ids(author_ids):
    result = {author_id: [] for author_id in author_ids}
    for post in posts:
        if post["authorId"] in author_ids:
            result[post["authorId"]].append(post)
    return result

def resolve_authors_with_posts():
    author_ids = [author["id"] for author in authors]
    posts_map = get_posts_by_author_ids(author_ids)
    result = []
    for author in authors:
        author_copy = author.copy()
        author_copy["posts"] = posts_map.get(author["id"], [])
        result.append(author_copy)
    return result

"""
# Add GraphQL schema types below
"""

Hint

Use GraphQL SDL syntax to define types with required fields and list of posts.

Practice

1. What is the N+1 problem in GraphQL?

easy

A. Making many small queries instead of one big query, causing slow performance.

B. A syntax error in GraphQL schema definitions.

C. Using too many variables in a single query.

D. Not using fragments in queries.

Solution

1. Step 1: Understand the N+1 problem context

   The N+1 problem happens when a query causes many small database calls instead of one efficient call.

2. Step 2: Identify the correct description

   Making many small queries instead of one big query, causing slow performance. correctly describes this as many small queries causing slow performance.

3. Final Answer:

   Making many small queries instead of one big query, causing slow performance. -> Option A

4. Quick Check:

   N+1 problem = many small queries [OK]

Hint: N+1 means many queries, not one big query [OK]

Common Mistakes:

• Confusing N+1 with syntax errors
• Thinking N+1 is about variables
• Assuming N+1 relates to fragments

2. Which of the following is a correct way to solve the N+1 problem in GraphQL?

easy

A. Avoid using fragments in queries.

B. Write multiple nested queries without batching.

C. Use DataLoader to batch and cache database requests.

D. Increase the number of resolvers for each field.

Solution

1. Step 1: Identify common solutions to N+1

   DataLoader is a popular tool that batches and caches requests to avoid many small queries.

2. Step 2: Match options with solutions

   Use DataLoader to batch and cache database requests. correctly states using DataLoader to fix N+1. Other options increase queries or do not help.

3. Final Answer:

   Use DataLoader to batch and cache database requests. -> Option C

4. Quick Check:

   DataLoader solves N+1 [OK]

Hint: Batch queries with DataLoader to fix N+1 [OK]

Common Mistakes:

• Thinking more resolvers fix N+1
• Ignoring batching and caching
• Confusing fragments with batching

3. Given this GraphQL resolver code snippet using DataLoader:

const userLoader = new DataLoader(ids => batchGetUsers(ids));

const resolvers = {
  Query: {
    posts: () => getAllPosts()
  },
  Post: {
    author: (post) => userLoader.load(post.authorId)
  }
};

What is the main benefit of using userLoader.load here?

medium

A. It delays all queries until the client disconnects.

B. It batches multiple authorId requests into a single database call.

C. It caches the entire posts list in memory.

D. It runs a separate query for each authorId immediately.

Solution

1. Step 1: Understand DataLoader's purpose

   DataLoader batches multiple calls to load data by IDs into one database call.

2. Step 2: Analyze the resolver code

   The userLoader.load(post.authorId) batches authorId requests to avoid many queries.

3. Final Answer:

   It batches multiple authorId requests into a single database call. -> Option B

4. Quick Check:

   DataLoader batches loads = It batches multiple authorId requests into a single database call. [OK]

Hint: DataLoader batches IDs to reduce queries [OK]

Common Mistakes:

• Thinking it runs separate queries immediately
• Confusing caching posts with batching authors
• Assuming queries delay until disconnect

4. You have this GraphQL resolver causing N+1 problem:

Post: {
  comments: (post) => getCommentsByPostId(post.id)
}

What is the best fix to avoid N+1 here?

medium

A. Add a delay before each comment fetch to reduce load.

B. Fetch comments inside the client instead of server.

C. Remove the comments field from the schema.

D. Replace with a batch loader that fetches comments for many post IDs at once.

Solution

1. Step 1: Identify the N+1 cause

   Calling getCommentsByPostId for each post causes many queries.

2. Step 2: Apply batching fix

   Using a batch loader to fetch comments for all post IDs in one query solves N+1.

3. Final Answer:

   Replace with a batch loader that fetches comments for many post IDs at once. -> Option D

4. Quick Check:

   Batch loading fixes N+1 [OK]

Hint: Batch fetch related data to fix N+1 [OK]

Common Mistakes:

• Adding delays does not fix query count
• Removing fields breaks schema
• Fetching on client doesn't reduce server queries

5. You have a GraphQL query fetching users and their posts:

{
  users {
    id
    posts {
      id
      title
    }
  }
}

Your current resolver fetches posts inside each user resolver causing N+1 queries. How can you optimize this with DataLoader and SQL to reduce queries?

hard

A. Create a batch loader that fetches posts for all user IDs in one SQL query using WHERE user_id IN (...).

B. Fetch posts one by one inside each user resolver without batching.

C. Remove posts from the query to avoid N+1.

D. Use a separate query for each post title.

Solution

1. Step 1: Identify the N+1 cause in nested posts

   Fetching posts inside each user resolver causes many queries, one per user.

2. Step 2: Use DataLoader with SQL batching

   Create a batch loader that runs one SQL query with WHERE user_id IN (list of user IDs) to get all posts at once.

3. Final Answer:

   Create a batch loader that fetches posts for all user IDs in one SQL query using WHERE user_id IN (...). -> Option A

4. Quick Check:

   Batch SQL query with DataLoader fixes N+1 [OK]

Hint: Batch SQL with WHERE IN for all IDs [OK]

Common Mistakes:

• Fetching posts one by one
• Removing needed fields
• Querying posts separately per post