Why federation scales GraphQL - Visual Breakdown

Concept Flow - Why federation scales GraphQL

Client sends query

↓

Gateway receives query

↓

Gateway splits query by service

↓

Send subqueries to respective services

↓

Services resolve subqueries

↓

Gateway collects and merges responses

↓

Gateway returns combined result to client

The gateway breaks a big query into smaller parts, sends them to different services, then merges results to handle large GraphQL schemas efficiently.

Execution Sample

GraphQL

query {
  user(id: "1") {
    name
    reviews {
      product {
        name
      }
    }
  }
}

A client requests user info and their product reviews, which the gateway splits and sends to user and review services.

Execution Table

Step	Action	Service	Query Part	Response	Gateway State
1	Receive full query	Gateway	Full query	N/A	Holds full query
2	Split query	Gateway	user(id: "1") { name }	N/A	Prepares user subquery
3	Split query	Gateway	user(id: "1") { reviews { product { name } } }	N/A	Prepares review subquery
4	Send subquery	User Service	user(id: "1") { name }	{"user": {"name": "Alice"}}	Waiting for review response
5	Send subquery	Review Service	user(id: "1") { reviews { product { name } } }	{"reviews": [{"product": {"name": "Book"}}]}	Has user and review data
6	Merge responses	Gateway	N/A	Combined user and reviews data	Ready to respond
7	Return combined result	Gateway	N/A	{"user": {"name": "Alice", "reviews": [{"product": {"name": "Book"}}]}}	Query complete

💡 All subqueries resolved and merged, gateway returns full response to client

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
fullQuery	Full client query	Full client query	Full client query	Full client query	Full client query
userSubquery	N/A	user(id: "1") { name }	Sent to User Service	Received user data	Merged in final response
reviewSubquery	N/A	user(id: "1") { reviews { product { name } } }	Waiting	Sent to Review Service	Merged in final response
responses	Empty	Empty	{"user": {"name": "Alice"}}	{"user": {"name": "Alice"}, "reviews": [{"product": {"name": "Book"}}]}	Complete combined data

Key Moments - 3 Insights

Why does the gateway split the query instead of sending it whole to one service?

Because each service owns part of the schema, splitting lets each service handle only its data, improving scalability and separation (see execution_table steps 2 and 3).

How does the gateway know how to merge responses correctly?

The gateway uses the schema federation metadata to combine fields from different services into one response, as shown in step 6 where responses are merged.

What happens if one service is slow or fails?

The gateway waits for all subqueries; if one is slow, the whole query response is delayed. Federation allows independent scaling to reduce such delays.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the gateway send the user subquery to the User Service?

A Step 4

B Step 2

C Step 5

D Step 6

💡 Hint

Check the 'Action' and 'Service' columns in execution_table rows

According to variable_tracker, what is the state of 'responses' after Step 5?

A Empty

B Contains only user data

C Contains user and review data

D Merged final response

💡 Hint

Look at the 'responses' row under 'After Step 5' column

If the gateway did not split the query, what would likely happen?

A The query would be faster because it's sent once

B One service would handle the entire query, reducing scalability

C The gateway would merge responses from multiple services

D The client would receive partial data only

💡 Hint

Refer to key_moments explanation about query splitting and service ownership

Concept Snapshot

GraphQL federation splits a big query into smaller parts.
Each part goes to the service owning that data.
Services resolve their parts independently.
Gateway merges all responses into one.
This lets GraphQL scale by dividing work across services.

Full Transcript

In GraphQL federation, a client sends a query to a gateway. The gateway breaks the query into smaller subqueries based on which service owns which part of the schema. It sends these subqueries to the respective services. Each service resolves its part and returns data. The gateway collects all responses and merges them into a single response for the client. This approach allows GraphQL to scale by distributing query resolution across multiple services, improving performance and maintainability.