Skip to main content

Learning path

GraphQL learning path: everything to study, topic by topic

Comprehensive GraphQL assessment covering schema design, type system, queries and mutations, resolvers, subscriptions, authentication and authorization, caching, pagination, rate limiting, federation, and testing strategies.

Short answer

To learn GraphQL, work through 6 modules and 22 topics in the order they build on each other. It starts with Schema & Types, then moves on to Queries & Mutations and Resolvers. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
22
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Schema & Types4 topics
  • Schema Basics

    Schema Definition Language (SDL), root types (Query, Mutation, Subscription), schema-first vs code-first approaches, introspection, and schema documentation

    Objectives

    • Write valid GraphQL schemas using SDL
    • Understand the role of root types in a schema

    Key concepts

    • SDL syntax
    • root types (Query, Mutation, Subscription)
    • schema-first design
    • code-first design
    • introspection
    • schema documentation
  • Scalar Types

    Built-in scalar types (Int, Float, String, Boolean, ID), custom scalar types, serialization and validation, and common custom scalars (DateTime, JSON, URL)

    Objectives

    • Identify and use built-in GraphQL scalar types correctly
    • Implement custom scalar types with proper serialization

    Key concepts

    • Int type
    • Float type
    • String type
    • Boolean type
    • ID type
    • custom scalars
    • scalar serialization
    • scalar validation
  • Object Types

    Object type definitions, field types, non-null (!) and list ([]) modifiers, enums, interfaces, unions, and type relationships

    Objectives

    • Design object types with proper nullability and list modifiers
    • Use interfaces and unions for polymorphism

    Key concepts

    • object type definition
    • non-null modifier (!)
    • list modifier ([])
    • enum types
    • interfaces
    • unions
    • type relationships
    • abstract types
  • Input Types

    Input object types for mutations, input validation patterns, differences between input and output types, and nested input types

    Objectives

    • Design input types for mutations with proper validation patterns
    • Distinguish between input and output type usage

    Key concepts

    • input keyword
    • input vs output types
    • nested input types
    • input validation
    • default values
    • required vs optional fields
2 · Queries & Mutations4 topics
  • Query Basics

    Query operations, field selection, nested queries, aliases, operation names, and query documents

    Objectives

    • Write GraphQL queries with proper field selection
    • Use aliases and operation names effectively

    Key concepts

    • query operation
    • field selection
    • nested queries
    • aliases
    • operation names
    • multiple queries
    • query documents
    • selection sets
  • Mutations

    Mutation operations, input arguments, return types, mutation response patterns, and optimistic updates

    Objectives

    • Design mutations with clear input and return types
    • Understand mutation execution semantics

    Key concepts

    • mutation operation
    • mutation arguments
    • mutation return types
    • mutation response patterns
    • sequential execution
    • side effects
  • Arguments & Variables

    Field arguments, query variables, variable types, default values, variable validation, and dynamic queries

    Objectives

    • Use variables to parameterize GraphQL operations
    • Apply proper variable type declarations

    Key concepts

    • field arguments
    • query variables ($)
    • variable types
    • default values
    • required variables (!)
    • variable validation
    • dynamic queries
    • inline arguments
  • Fragments

    Fragment definitions, fragment spreads, inline fragments, type conditions, fragment composition, and DRY query patterns

    Objectives

    • Use fragments to reduce query duplication
    • Apply inline fragments for polymorphic types

    Key concepts

    • fragment definition
    • fragment spread (...)
    • inline fragments
    • type conditions (on)
    • fragment composition
    • reusable selections
    • polymorphic queries
    • fragment colocation
3 · Resolvers4 topics
  • Resolver Basics

    Resolver functions, resolver signature (parent, args, context, info), default resolvers, resolver chain, and return types

    Objectives

    • Implement resolver functions with proper argument handling
    • Understand the resolver execution chain

    Key concepts

    • resolver function
    • resolver arguments (parent, args, context, info)
    • default resolvers
    • resolver chain
    • resolver return types
    • promise-based resolvers
    • field-level resolvers
    • type resolvers
  • Data Sources

    Connecting resolvers to databases, REST APIs, microservices, data source abstraction, and ORM integration

    Objectives

    • Connect GraphQL resolvers to various data sources
    • Abstract data access patterns for maintainability

    Key concepts

    • database integration
    • REST API wrapping
    • data source abstraction
    • ORM integration
    • connection pooling
    • data source caching
    • microservice communication
    • batch loading
  • N+1 Problem

    Understanding the N+1 query problem in GraphQL, DataLoader pattern, batching and caching, and query optimization techniques

    Objectives

    • Identify and resolve N+1 query problems
    • Implement DataLoader for efficient batch loading

    Key concepts

    • N+1 query problem
    • DataLoader pattern
    • batching requests
    • per-request caching
    • batch function implementation
    • DataLoader caching strategies
    • query planning
    • join monster/join approaches
  • Context & Middleware

    GraphQL context object, middleware patterns, resolver wrappers, request lifecycle hooks, and plugin systems

    Objectives

    • Design context objects for request-scoped data
    • Implement middleware patterns for cross-cutting concerns

    Key concepts

    • context object
    • context building
    • middleware patterns
    • resolver wrappers
    • field-level middleware
    • request lifecycle
    • plugin architecture
    • extensions
4 · Subscriptions & Security4 topics
  • Subscriptions

    GraphQL subscriptions, WebSocket transport, pub/sub patterns, subscription resolvers, and real-time event filtering

    Objectives

    • Implement real-time subscriptions with proper transport
    • Design event-driven subscription resolvers

    Key concepts

    • subscription type
    • WebSocket protocol
    • pub/sub pattern
    • subscription resolver
    • event filtering
    • subscription lifecycle
    • graphql-ws protocol
    • subscription scaling
  • Authentication

    Authentication in GraphQL APIs, JWT integration, session management, token validation in context, and login/logout mutations

    Objectives

    • Implement authentication flows in GraphQL
    • Validate tokens and inject user context

    Key concepts

    • JWT authentication
    • token validation
    • context-based auth
    • login mutations
    • session management
    • refresh tokens
    • API key authentication
    • OAuth integration
  • Authorization

    Field-level authorization, directive-based auth, role-based access control, resolver-level permissions, and authorization middleware

    Objectives

    • Implement field-level authorization in GraphQL
    • Design scalable permission systems

    Key concepts

    • field-level authorization
    • directive-based auth (@auth)
    • role-based access control
    • resolver-level permissions
    • authorization middleware
    • data-level authorization
    • schema directives for auth
    • permission composition
  • Error Handling

    GraphQL error format, error extensions, partial data responses, error classification, and custom error types

    Objectives

    • Design error handling strategies for GraphQL APIs
    • Implement custom error types with proper extensions

    Key concepts

    • GraphQL error format
    • error extensions
    • partial data responses
    • error classification
    • custom error types
    • error masking
    • error codes
    • union-based error handling
5 · Performance3 topics
  • Caching

    HTTP caching challenges with GraphQL, response caching, normalized caching, cache invalidation, CDN strategies, and persisted queries

    Objectives

    • Design caching strategies for GraphQL APIs
    • Implement persisted queries for performance

    Key concepts

    • HTTP caching challenges
    • response caching
    • normalized cache
    • cache invalidation
    • CDN strategies
    • persisted queries
    • automatic persisted queries (APQ)
    • cache-control directives
  • Pagination

    Cursor-based pagination, offset pagination, Relay connection specification, edges, nodes, pageInfo, and pagination design patterns

    Objectives

    • Implement Relay-compliant cursor pagination
    • Choose between pagination strategies based on requirements

    Key concepts

    • cursor-based pagination
    • offset pagination
    • Relay connection spec
    • edges and nodes
    • pageInfo type
    • first/after/last/before args
    • total count
    • pagination performance
  • Rate Limiting

    Query complexity analysis, depth limiting, breadth limiting, cost-based rate limiting, and query whitelisting

    Objectives

    • Implement query complexity analysis for rate limiting
    • Design cost-based throttling for GraphQL APIs

    Key concepts

    • query complexity analysis
    • depth limiting
    • breadth limiting
    • cost-based rate limiting
    • query whitelisting
    • static analysis
    • complexity scoring
    • throttling strategies
6 · Advanced Patterns3 topics
  • Schema Design

    Schema design principles, naming conventions, Relay specification, schema evolution, deprecation, and versioning strategies

    Objectives

    • Design scalable and evolvable GraphQL schemas
    • Apply naming conventions and Relay principles

    Key concepts

    • schema design principles
    • naming conventions
    • Relay specification
    • schema evolution
    • deprecation (@deprecated)
    • versioning strategies
    • global object identification
    • schema stitching
  • Federation

    Apollo Federation, subgraph composition, entity references, @key directive, federated types, and gateway architecture

    Objectives

    • Design federated GraphQL architectures
    • Implement entity resolution across subgraphs

    Key concepts

    • Apollo Federation
    • subgraph composition
    • @key directive
    • @external directive
    • @requires directive
    • entity references
    • gateway architecture
    • federated query planning
  • Testing

    Unit testing resolvers, integration testing GraphQL APIs, schema validation, mocking, and end-to-end testing strategies

    Objectives

    • Write comprehensive tests for GraphQL APIs
    • Implement testing strategies at multiple levels

    Key concepts

    • unit testing resolvers
    • integration testing
    • schema validation
    • mocking resolvers
    • snapshot testing
    • query testing
    • mutation testing
    • end-to-end testing

Levels: Junior, Mid, and Senior

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying GraphQL?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying GraphQL?

Start with Schema & Types: Schema Basics, Scalar Types, and Object Types. The map orders topics by what they depend on, so each one prepares the next.

How long does a full GraphQL assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.