How much GraphQL do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can build a working GraphQL API.”
Start with the schema and the type system, then queries, mutations and resolvers — a small API and a client talking to it.
- You know REST APIs and basic Node/Express
- You haven't written a GraphQL schema or resolver yourself
- You want queries, mutations and resolvers once, in order
“I can design a real schema.”
You can query and mutate. Now design a schema that scales: nullability, pagination, auth, real-time subscriptions, and a cache that stays correct.
- Comfortable with queries, mutations and basic resolvers
- You've hit the N+1 problem and just added more resolvers
- You want a schema and client cache a real app can grow into
“I can run GraphQL in production.”
Federation, query-cost security, and the honest comparison against REST and tRPC — the decisions behind a GraphQL gateway at scale.
- You can already design a paginated, authenticated schema
- You debug slow resolvers and abusive queries, not just N+1s
- You want the why under federation and query-complexity limits
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner0 / 7 sections written
- What GraphQL is & whycoming soon
vs REST, the core ideas
- Schema & typescoming soon
Scalars, object types, the type system
- Queriescoming soon
Fields, arguments, variables
- Mutationscoming soon
Writing data
- Resolverscoming soon
How a query actually becomes data
- Setting up a GraphQL servercoming soon
Apollo Server / GraphQL Yoga basics
- A GraphQL clientcoming soon
Apollo Client / urql basics, fetching in a UI
✅ Checkpoint: you can design a small schema, write its resolvers, and query it from a real client, without copying a tutorial.
Intermediate0 / 8 sections written
- Schema designcoming soon
Nullability, input types, enums, interfaces/unions
- The N+1 problem & DataLoadercoming soon
Batching and caching resolver calls
- Authentication & authorizationcoming soon
Guarding fields and resolvers
- Error handlingcoming soon
Errors in a GraphQL response, partial data
- Pagination patternscoming soon
Cursor-based (Relay-style) vs offset pagination
- Subscriptionscoming soon
Real-time GraphQL
- Caching in GraphQL clientscoming soon
Normalized caches, updating after a mutation
- Testing a GraphQL APIcoming soon
Testing resolvers and schema behavior
✅ Checkpoint: you can design a paginated, authenticated schema with DataLoader-batched resolvers, and keep a normalized client cache correct after mutations.
Advanced0 / 7 sections written
- Federation & schema stitchingcoming soon
Splitting a graph across services
- Performancecoming soon
Query complexity limits, depth limiting, persisted queries
- Security in GraphQLcoming soon
Introspection in production, rate limiting by query cost
- Code-first vs schema-first at scalecoming soon
The tradeoffs once a team is involved
- GraphQL vs REST vs tRPCcoming soon
When each one actually wins
- Monitoring a GraphQL APIcoming soon
Tracing resolver performance
- A production-grade GraphQL gatewaycoming soon
Putting the pieces together
✅ Checkpoint: you can split a graph across services with federation, defend a query-cost limiting strategy, and make the call between GraphQL, REST and tRPC with reasons.
- The N+1 problem and DataLoader get their own intermediate chapter because it's the single most common "why is this GraphQL API slow" answer — it deserves more than a footnote inside resolvers.
- GraphQL vs REST vs tRPC is placed in advanced, not beginner, on purpose — that comparison only means something once you've actually built resolvers, pagination and auth in GraphQL yourself.
- Federation is the deepest, most infrastructure-shaped layer — most teams building a single GraphQL API never need it, but the advanced tier doesn't skip it.