AWS AppSync is a fully managed GraphQL API service that connects your schema to data sources like DynamoDB, Lambda, and RDS. It handles query resolution, real-time subscriptions, and offline sync without any servers to manage.
AppSync replaces custom GraphQL server infrastructure with a managed service that handles schema parsing, resolver execution, and data source orchestration.
Define your GraphQL schema and AppSync provides a fully managed endpoint. No Apollo Server, Express, or container infrastructure to run or scale.
Connect resolvers directly to DynamoDB, RDS Aurora, OpenSearch, Lambda, or any HTTP endpoint. Aggregate data from multiple sources in a single query.
Built-in GraphQL subscriptions push data to connected clients over WebSockets. No custom pub/sub infrastructure needed for live updates.
Support for Cognito User Pools, IAM roles, OpenID Connect, and API keys. Multiple auth modes can be configured on the same API.
Combined with AWS Amplify, AppSync supports offline data access and automatic conflict resolution when clients reconnect, ideal for mobile apps.
Chain multiple resolver functions together in sequence. Execute authorization checks, data transformations, and data fetches in a single request pipeline.
AppSync sits between your clients and your data sources, translating GraphQL operations into data source requests and assembling the response.
A client sends a GraphQL query, mutation, or subscription. AppSync validates the operation against your schema and runs any configured authentication checks.
AppSync executes the resolver mapped to each field. Resolvers connect to DynamoDB, Lambda, RDS, or HTTP endpoints to fetch or modify data. Pipeline resolvers chain multiple steps.
AppSync assembles data from all resolvers into a single JSON response matching the shape requested by the client. For subscriptions, updates are pushed in real time.
AppSync resolvers connect directly to these AWS services and external endpoints:
The most common data source for AppSync. Map GraphQL types directly to DynamoDB tables with automatic CRUD resolver templates.
Run custom business logic for any resolver. Use Lambda when you need complex transformations or access to unsupported data stores.
Query relational databases using the Data API. Supports Aurora Serverless for SQL-based data access without managing connections.
Full-text search and analytics queries mapped to GraphQL fields. Ideal for search, filtering, and aggregation use cases.
Call any REST API or third-party service as a data source. Useful for integrating with external systems and legacy services.
Resolve fields locally without calling an external data source. Useful for computed fields, static values, and pipeline orchestration.
The Serverless Framework supports AppSync through its plugin ecosystem. Define your GraphQL schema, data sources, and resolvers in serverless.yml alongside your Lambda functions:
service: my-graphql-api
provider:
name: aws
runtime: nodejs22.x
plugins:
- serverless-appsync-plugin
custom:
appSync:
name: MyGraphQLApi
authentication:
type: AMAZON_COGNITO_USER_POOLS
config:
userPoolId: !Ref CognitoUserPool
dataSources:
usersTable:
type: AMAZON_DYNAMODB
config:
tableName: !Ref UsersTable
postsResolver:
type: AWS_LAMBDA
config:
functionName: getPosts
resolvers:
Query.getUser:
dataSource: usersTable
Query.listPosts:
dataSource: postsResolver
functions:
getPosts:
handler: handler.getPostsThe serverless-appsync-plugin handles all CloudFormation resource creation: the AppSync API, schema upload, data source connections, resolver mappings, and IAM roles. Your GraphQL schema file lives alongside your code and deploys automatically.
AppSync eliminates the need to run, scale, and maintain your own GraphQL server. No Apollo Server instances, no Express middleware, no container orchestration. Define your schema and resolvers, and AppSync handles parsing, validation, execution, and scaling automatically.
GraphQL subscriptions work out of the box over managed WebSocket connections. Clients receive automatic updates when data changes, without polling. Combined with Amplify client libraries, you get real-time data sync for web and mobile apps with minimal code.
A single GraphQL query can resolve fields from DynamoDB, Lambda, RDS, and HTTP endpoints simultaneously. AppSync assembles the response from all data sources into one payload. This replaces the frontend pattern of making multiple REST calls and stitching results together.
Combined with the Amplify Framework, AppSync provides offline data access with automatic conflict resolution. Mobile apps continue working without connectivity and sync changes when they reconnect. This is particularly valuable for field service, delivery, and healthcare applications.
AppSync is the right choice for many GraphQL APIs, but these constraints are worth evaluating before committing.
GraphQL requires a paradigm shift from REST. Teams need to learn schema design, resolver patterns, and client-side query management. Specialized tooling like Amplify adds another layer of concepts.
As a managed service, AppSync does not expose internal performance metrics or tuning parameters. You cannot adjust connection pooling, resolver timeouts at a granular level, or caching behavior within the resolver pipeline.
AppSync natively supports DynamoDB, RDS Aurora, OpenSearch, and HTTP endpoints. For MongoDB, Redis, PostgreSQL (non-Aurora), or other data stores, you need a Lambda function as an intermediary.
AppSync uses proprietary resolver mapping templates (VTL or JavaScript) and service-specific configuration. Migrating to Apollo Server, Hasura, or another GraphQL provider requires rewriting resolvers and infrastructure.
GraphQL queries must complete within 30 seconds. For complex aggregations or slow downstream services, you may need to break queries into smaller operations or use async patterns.
AppSync pricing is based on query/mutation volume, real-time updates, connection minutes, and data transfer. There are no upfront costs.
250K
queries + mutations / month
250K
real-time updates / month
600K
connection minutes / month
| Component | Price |
|---|---|
| Queries and mutations | $4.00 / 1M requests |
| Real-time updates | $2.00 / 1M updates |
| Connection minutes | $0.08 / 1M minutes |
| Data transfer | $0.09 / GB |
30M requests x $4.00/1M = $120.00/month
143 GB transfer x $0.09/GB = $12.87/month
Total AppSync charges: $132.87/month
Plus separate charges for DynamoDB, Lambda, and other backend services used by your resolvers.
See the official AppSync pricing page for current regional rates.
Use AppSync when you are building a GraphQL API, need real-time subscriptions, want managed data source integrations with DynamoDB or RDS, or are building mobile apps that require offline sync and conflict resolution. AppSync is the fastest way to go from schema to production GraphQL endpoint on AWS.
Consider alternatives when you need fine-grained control over GraphQL server behavior (use Apollo Server or Hasura), want to avoid vendor lock-in with portable resolver code, or are building a simple REST API that does not benefit from the GraphQL query model (use HTTP APIs or API Gateway instead).
Key quotas to plan around. Most soft limits can be raised through AWS Support.
| Limit | Value |
|---|---|
| APIs per account per region | 25 (adjustable) |
| Schema size | 1 MB max |
| Query execution timeout | 30 seconds |
| Queries per second | 1,000 default (adjustable) |
| Subscriptions per connection | 100 |
| API keys per API | 50 |
| Resolvers per API | 10,000 |
| Custom domains per account | 25 |
| WebSocket connection timeout | 24 hours |
| Payload size | 1 MB response |
AppSync is not the only way to build a GraphQL API. These alternatives may be a better fit depending on your requirements.
Open-source GraphQL server you can self-host or run on Apollo Cloud. Best for multi-cloud deployments and teams that want maximum flexibility over resolver logic, caching, and federation.
Open-source GraphQL engine that sits on top of PostgreSQL and auto-generates CRUD operations from your database schema. Best for rapid API development on relational data with minimal custom resolver code.
ORM and data layer for Node.js and TypeScript. Not a direct AppSync replacement, but a popular choice for building GraphQL backends with type-safe database access and auto-generated queries.
Build a custom GraphQL endpoint by routing all requests through a single Lambda function running Apollo Server or another library. More control over the runtime, but more operational work.
Common questions about AWS AppSync.
Deploy an AppSync GraphQL API with DynamoDB and Lambda in minutes using the Serverless Framework.