GraphQL Mastery Path¶
GraphQL lets a client describe exactly the data it wants — a book, its author's name, the three latest reviews — and get back JSON in exactly that shape from one endpoint, validated against a typed schema before any server code runs. That's why product teams adopt it: one request instead of a waterfall, generated types instead of guesswork, and a schema that documents itself. It's also why GraphQL servers fail in recognisable ways: a list query that quietly runs a thousand SQL statements, a 127-character query that makes a server do a hundred thousand resolver calls, a private object that's protected on one path and readable through another, a database error message delivered to every client, a field removed while an old mobile app still asks for it. This course teaches you to build GraphQL APIs and to understand the machinery well enough to avoid all of those.
Level 1 starts from nothing: the type system, the query language, resolvers and the four
arguments they receive, mutations and input types, serving over HTTP with Apollo Server, how
errors and partial data work, introspection — ending with a tested library API. Level 2
adds real data and real design: client-shaped schemas, interfaces and unions, custom scalars,
SQLite, the N+1 problem measured and fixed with DataLoader, cursor pagination, mutation payloads
with errors as data, and a layered test suite — ending with a bookstore API. Level 3 is
production concerns: JWT authentication, authorization on every path, schema directives,
subscriptions over WebSockets, depth and cost limits, caching and persisted queries, Apollo
Client's normalized cache, code generation and the GraphQL-over-HTTP rules — ending with a
real-time task board. Level 4 goes inside and beyond: graphql-js internals, tracing,
Apollo Federation with real query plans, schema evolution, error masking, code-first schemas in
JavaScript and Python, graphql-js 17 and @defer, an architecture review, and a federated
storefront capstone.
Every lesson has a How It Actually Works section — how the executor chains resolvers through
parent, why one ! can null out a whole response, how DataLoader collects keys within a single
tick, why a cache redirect makes book(id:) hit the cache, how a router turns one query into a
plan of _entities calls.
Run, not imagined
Code, commands, responses and error messages in this course come from real runs on Node.js 26.3 with graphql 16.14.2, Apollo Server 5.5.1, DataLoader 2.2.3, graphql-ws 6.3.0, Apollo Client 4.3.3, @apollo/subgraph 2.15.1 and @apollo/gateway 2.14.4, plus graphql 17.0.2 with GraphQL Yoga 5.24.4 and Strawberry 0.332.0 on Python 3.14 where noted. Several lessons show first attempts that failed — a plugin hook that crashed instead of returning an error, generated TypeScript a NodeNext project rejected, a federation helper that rejected the commonly documented call form — because you'll meet those too. Each level page lists what was run and what wasn't (no external databases, brokers, CDNs, identity providers or Apollo GraphOS account were used). Timings are one laptop's results, not benchmarks.
How the program is organized¶
| Level | Focus | Modules |
|---|---|---|
| Level 1 · Entry | What GraphQL is, graphql-js, the type system, queries, resolvers, mutations and inputs, Apollo Server over HTTP, errors and null propagation, introspection | 9 topics + 1 project (a library catalog API with tests) |
| Level 2 · Intermediate | Schema design, interfaces and unions, custom scalars, SQLite and context, N+1, DataLoader, pagination, mutation design, testing | 9 topics + 1 project (a bookstore API on SQLite) |
| Level 3 · Advanced | Authentication, authorization, schema directives, subscriptions, security limits, caching and persisted queries, clients, codegen, GraphQL over HTTP | 9 topics + 1 project (a real-time task board with auth) |
| Level 4 · Master | graphql-js internals, plugins and tracing, federation, schema evolution, production errors, code-first, Yoga and graphql-js 17, architecture review | 9 topics + 1 capstone (a federated storefront graph) |
How to use this site¶
- Know your JavaScript first. The examples use modern JavaScript on Node.js: modules,
async/await, destructuring. If those are unfamiliar, start with JavaScript Mastery Path and Node.js Mastery Path. - Run every example. Each lesson's code is complete enough to paste into a file and run; the outputs shown are what it printed. If yours differ, check the versions on the level page.
- Read the errors and count the queries. GraphQL's validation messages and a statement counter tell you most of what you need when something is wrong. Several lessons start from them.
- Related courses. For resource-oriented API design, see REST API Mastery Path; for SQL itself, SQL Mastery Path; for typed clients, TypeScript Mastery Path; for the UI side, React Mastery Path; for the big picture, System Design Mastery Path.
- Do the Exercise at the end of each lesson; the module-10 projects build on them.
Start here → Level 1 · Entry
🎥 Prefer video? Watch the Mastery Path video series on YouTube — Shorts and full walkthroughs of lessons across the series.
More from the Mastery Path series¶
Free, structured, module-wise training across 79 other languages, platforms and disciplines:
Languages
Web Frameworks
Testing & QA
Security
Cloud Platforms
Data & Analytics
AI / ML / LLM
Embedded Systems
Leadership & Management
Professional Skills
Careers & Interviews
Process & APIs
Infrastructure & Ops