Continue learning

1

Meet the AppSync League

Trace how a trainer's Pokédex request travels through an AppSync GraphQL API to a data source and back.

2

Open the Pokédex

Ask for exactly the Pokémon fields the client needs instead of accepting a fixed response shape.

3

Shape the Pokémon schema

Define the typed contract that every trainer, resolver, and tool can understand.

4

Pack a query variable

Reuse one operation for every Pokémon while retaining validation and safe client tooling.

5

Register a new Pokémon

Model writes with a reusable input type and request the authoritative fields returned after the mutation.

6

Wire a DynamoDB resolver

Translate a GraphQL field into a direct DynamoDB GetItem request without a Lambda function.

7

Handle resolver results

Return successful data, preserve partial GraphQL responses, and surface a useful error when a Pokémon is missing.

8

Choose the right data source

AppSync can combine multiple backends. Pick a direct source for simple work and Lambda only for logic that needs it.

9

Turn the Pokédex page

Query the Kanto partition in manageable pages using AppSync's opaque DynamoDB cursor.

10

Build a resolver pipeline

Compose authorization, fetching, and enrichment functions while passing state through stash and prev.result.

11

Choose an authorization mode

Give trainers, AWS services, public demos, and partners the correct way into the API.

12

Guard the private Gym

Enforce record ownership inside the resolver after the request passes the API authorization mode.

13

Broadcast an evolution

Connect a secure WebSocket subscription to the mutation that publishes evolution events.

14

Filter the evolution feed

Keep each trainer's Pokédex feed private by applying a server-controlled enhanced filter.

15

Tune the API cache

Reduce repeated reads for stable species data without caching private or rapidly changing battle state.

16

Watch the League

Choose the signals needed to diagnose slow requests and resolver failures without logging sensitive trainer data.

17

Deploy the League with CDK

Make the GraphQL API reproducible by defining its schema, authorization, and logging in infrastructure code.

18

Choose GraphQL or AppSync Events

Finish the League by choosing typed GraphQL subscriptions for domain data and AppSync Events for pure PubSub channels.

19

Build a reusable Pokédex card

Reuse one field set across multiple Pokémon, rename results for the client, and identify concrete response types.

20

Classify every encounter

Model shared identity, closed categories, and results that may take more than one concrete shape.

21

Defeat the N+1 swarm

A nested resolver receives one parent in ctx.source; it does not receive every parent automatically. Redesign the parent request to fetch known partner keys together.

22

Set a query power limit

Flexible queries can become expensive when clients request deep connections or very large pages.

23

Batch a Lambda expedition

Use Lambda only where custom compute is justified and let AppSync coalesce nested field executions into a bounded batch.

24

Call a protected AWS route

Integrate an HTTP endpoint without placing credentials in resolver code or leaking sensitive headers into logs.

25

Match data to its natural habitat

Choose a direct integration based on access pattern rather than placing every workload behind Lambda.

26

Transfer a Pokédex photo safely

Keep large binary files outside GraphQL while authorizing uploads and storing durable file metadata.

27

Fortify the public Gym

Protect a public GraphQL endpoint with layered controls instead of relying on authentication alone.

28

Unite regional Pokédex teams

Let independent teams own source APIs while presenting clients with one composed AppSync endpoint.

29

Keep the Pokédex online

Production clients must survive expired cursors, dropped WebSockets, duplicates, and out-of-order events.

30

Deploy the Champion League

Finish with a reproducible API, DynamoDB source, APPSYNC_JS resolver, contract tests, and guarded rollout.