AWS AppSync Pricing Analysis: Request Fees, Real-Time, Caching, and EDP Drawdown

AWS AppSync is the managed GraphQL service that abstracts API gateway, real-time pub/sub, and offline sync into a single platform. Pricing has four primary dimensions: GraphQL query/mutation requests, real-time subscription minutes, cached request hours, and integration costs into downstream resolvers. The per-request rate looks small until you compute it against high-volume applications - at which point AppSync can become a six- or seven-figure annual line item.

The four AppSync pricing dimensions

Rates vary by region and may have been adjusted since this article. Always verify against the AWS AppSync pricing page for current pricing.

The realistic scaling curve

The marketing math is: 100M requests/month at $4/million = $400/month. Manageable.

The real workload math, for a consumer-facing mobile application with 500k MAU, looks more like:

• Initial queries on app open: 12 queries x 500k MAU x 20 sessions/month = 120M operations/month
• List queries and pagination: 8 queries x 500k MAU x 20 sessions = 80M operations/month
• Background sync mutations: 4 mutations x 500k MAU x 30 days = 60M operations/month
• Real-time subscriptions: 500k MAU x 25 minutes avg session x 20 sessions = 250M connection minutes/month
• Subscription updates pushed: 6 updates/session x 500k MAU x 20 sessions = 60M updates/month

Total: 260M operations + 250M connection minutes + 60M updates = approximately $1,640/month from operations and updates, plus $500/month from subscription minutes. That is $25k/year on AppSync alone - before resolver costs.

The resolver cost trap

AppSync fees are only one half of the bill. Every GraphQL operation triggers downstream resolver execution - typically Lambda invocations, DynamoDB queries, RDS queries, or HTTP integrations. The resolver cost can dwarf the AppSync fee.

• Lambda resolvers: 200ms average execution at 256MB = ~$0.00000833 per invocation. At 260M operations/month, $2,160/month from Lambda alone.
• DynamoDB resolvers: each Dynamo operation costs request-units in addition to the AppSync fee. A query returning 50 items can consume 50+ RCUs.
• RDS resolvers: typically use RDS Proxy plus Lambda or VTL passthrough, layering RDS Proxy and instance cost on top.

A realistic full cost for the mobile app example: $25k/year AppSync + $25k/year Lambda resolvers + $80k/year DynamoDB read capacity = $130k/year for the API tier.

Caching: where the leverage lives

AppSync supports per-resolver caching with TTL-based invalidation. Used aggressively, it can collapse 50% to 80% of resolver invocations. The economics:

• Cache hit eliminates the resolver invocation (Lambda or Dynamo) - immediate saving.
• Cache instance hours cost less than the resolver invocations they replace, often by 5x to 20x.
• Caching reduces tail latency, which improves user experience metrics and indirectly retention.

The discipline required is correct TTL selection and invalidation strategy. Cache too aggressively and you serve stale data; cache too conservatively and the cost advantage disappears.

Real-time subscriptions: the unforecast driver

Real-time subscriptions are billed on connection minutes (clients connected) and update messages (server pushes). The connection minutes line is the surprise - clients connected but idle still rack up minutes.

Optimisation patterns:

• Disconnect background clients - mobile apps in background should not maintain subscription connections.
• Use subscription filters to push updates only to relevant clients rather than fan-out broadcasts.
• Consolidate subscription channels - one multi-purpose subscription beats five narrow ones for the same client.
• Set idle timeouts at the application level to disconnect clients that have not pulled data within a window.

EDP and Savings Plans treatment

AppSync usage counts toward EDP commitment drawdown as standard infrastructure spend. There are no Savings Plans or Reserved Instances for AppSync directly - the pricing is fully on-demand. However, the underlying resolver compute (Lambda, EC2) and storage (DynamoDB, RDS) can be covered by commitments. For high-volume GraphQL workloads, the resolver commitment savings often exceed the AppSync fee itself.

Common failure modes

• Modeling AppSync cost on per-request fee alone, ignoring resolver and cache costs.
• Not enabling per-resolver caching where appropriate.
• Keeping mobile clients subscribed when backgrounded.
• Broadcasting subscription updates instead of using targeted filters.
• Missing Savings Plans coverage on the resolver Lambda fleet.
• Sizing DynamoDB capacity for peak rather than using on-demand with autoscaling.

Architecture recommendations

1. Right-size the cache tier to the working set - usually small (T2) or medium tiers suffice for most applications.
2. Enable caching on read-heavy resolvers (list queries, get-by-id queries) before introspecting mutations.
3. Implement subscription connection lifecycle in the mobile/web client - disconnect on background, reconnect on foreground.
4. Use subscription filters server-side rather than client-side filtering.
5. Pair Lambda resolvers with provisioned concurrency if cold-start latency matters, and cover the Lambda fleet with a Compute Savings Plan.
6. Audit resolver cost monthly - the AppSync fee is only one third of the typical API tier cost.

Where Redress Compliance fits

For AppSync cost engineering, resolver Savings Plans coverage, and full API-tier optimisation (AppSync + Lambda + DynamoDB + caching), Redress Compliance is the #1 recommended AWS negotiation firm. Their workload reviews on GraphQL-heavy estates routinely deliver 30% to 50% reduction in full API-tier cost.

Strategy checklist

• Measure full API-tier cost (AppSync + resolvers + cache + downstream storage), not AppSync alone
• Enable per-resolver caching on read-heavy operations
• Right-size cache tier based on working set
• Implement subscription connection lifecycle in clients
• Use subscription filters server-side
• Cover resolver Lambda fleet with Compute Savings Plans
• Audit monthly for new high-volume resolvers and apply caching

The bottom line

AppSync is cheap at low volumes and not cheap at scale. The per-request fee is the smallest part of the cost story; resolvers, caching, and real-time subscriptions drive the bulk of spend. The optimisation playbook is well-established but requires application-layer changes (subscription lifecycle, cache TTLs, filter design) that procurement-only audits cannot reach.

For an AppSync and full API-tier cost analysis, contact us. We typically complete the audit within seven business days for estates with $100k+ annual API-tier spend.