The Real Cost of AWS Amplify — What the Pricing Page Won't Tell You
The Real Cost of AWS Amplify — What the Pricing Page Won’t Tell You
TL;DR: Amplify charges a 67% markup on data transfer ($0.15/GB vs $0.09/GB raw) and 5x on build minutes ($0.01/min vs $0.002/min via CodePipeline). The real costs hide behind the services it provisions: Cognito slashed its free tier 80% in December 2024 (50K to 10K MAU), AppSync charges $4/million queries (20x more than Lambda), and there’s no hard spending cap. Real horror stories: $1,124 from following the official tutorial, $2,300/month from a stuck deployment. Cognito can’t export password hashes — if you leave, your users reset their passwords. Evaluate carefully before adopting.
AWS Amplify is seductive. Run a few commands, deploy a full-stack app with authentication, a GraphQL API, a database, and hosting — all without touching the AWS console. For prototypes and hackathons, it’s magic.
But magic has a price. And that price isn’t on the pricing page.
After investigating official documentation, GitHub issues, developer post-mortems, and community discussions, a pattern emerges: Amplify’s cost isn’t what you pay — it’s what you don’t know you’ll pay. The pricing page shows you hosting rates. The real bill comes from the services Amplify provisions behind the scenes, the markups over raw AWS equivalents, and the migration costs when you eventually outgrow it.
What the Pricing Page Shows You
Let’s start with what AWS tells you upfront. According to the official Amplify pricing page:
Hosting
| Component | Free Tier | Paid Rate |
|---|---|---|
| Data storage (CDN) | 5 GB/month | $0.023 per GB/month |
| Data transfer out | 15 GB/month | $0.15 per GB served |
Build & Deploy
| Instance Type | Specs | Free Tier | Paid Rate |
|---|---|---|---|
| Standard | 8 GB RAM, 4 vCPUs | 1,000 min/month | $0.01/min |
| Large | 16 GB RAM, 8 vCPUs | None | $0.025/min |
| XLarge | 72 GB RAM, 36 vCPUs | None | $0.10/min |
Server-Side Rendering (SSR)
| Component | Free Tier | Paid Rate |
|---|---|---|
| Request count | 500,000 requests/month | $0.30 per 1 million requests |
| Request duration | 100 GB-hours/month | $0.20 per GB-hour |
Security
Web Application Firewall (WAF): $15/month per Amplify app (prorated hourly), plus separate AWS WAF charges ($5/month per web ACL + $1/rule + per-request fees). Minimum total: ~$22/month per app.
This looks reasonable. A small team of 5 developers pushing 2 commits/day would pay roughly $8/month for hosting. But this is just the tip.
The Convenience Tax
Amplify isn’t a standalone service — it’s an abstraction layer over other AWS services. And that abstraction comes with a markup.
A Medium analysis by Kavindu Vindika broke down the numbers:
| Dimension | Amplify Price | Raw AWS Price | Markup |
|---|---|---|---|
| Data transfer out | $0.15/GB | $0.09/GB (EC2/S3) | ~67% |
| Build minutes | $0.01/min | $0.002/min (CodePipeline) | ~400% |
| CDN delivery | $0.15/GB served | $0.085-$0.12/GB (CloudFront) | 25-76% |
Data Transfer: The Silent Multiplier
The 15 GB/month free tier sounds generous until you realize that Vercel offers 100 GB free and Cloudflare Pages offers unlimited free bandwidth. And when you exceed it, Amplify’s $0.15/GB is the most expensive option in the ecosystem.
A detailed comparison on DEV.to calculated the concrete difference for the Tokyo region:
| Monthly Transfer | CloudFront Cost | Amplify Cost | Extra You Pay |
|---|---|---|---|
| 100 GB | $0.00 (free tier) | $12.75 | +$12.75 |
| 500 GB | $0.00 (free tier) | $72.75 | +$72.75 |
| 1 TB | $0.00 (free tier) | $151.35 | +$151.35 |
| 10 TB | $1,025.02 | $1,507.50 | +$482.48 |
Here’s the critical detail: Amplify does not benefit from CloudFront’s 1 TB/month free tier. Even though Amplify uses CloudFront behind the scenes, its billing is separate. You’re paying a premium for a service that uses a cheaper service internally.
Build Minutes: Slow and Expensive
Amplify builds are notoriously slow. Multiple GitHub issues document the problem:
- A small Next.js app with only 2 static pages takes ~10 minutes on Amplify, compared to 2-3 minutes on Netlify or Vercel.
- Backend deployments with CloudFormation can take 20+ minutes per build.
- Users have requested faster deployments for years.
One developer found a counterintuitive optimization. In a detailed writeup on HackMD, they achieved a ~50% reduction in build times by disabling Amplify’s default caching entirely — the platform spent more time compressing and decompressing a 2,873 MB cache artifact than simply reinstalling dependencies from scratch.
At $0.01/minute, slow builds don’t just waste time — they waste money. And at 5x the cost of CodePipeline, every wasted minute costs more than it should.
The Costs Behind the Abstraction
When you add authentication, an API, or a database through Amplify, it provisions real AWS services. Each has its own pricing — and some have recently gotten more expensive.
Amazon Cognito: The 80% Free Tier Reduction
Cognito handles authentication for Amplify apps. In December 2024, AWS restructured Cognito pricing significantly:
Before (pre-December 2024):
- 50,000 MAU free
After (December 2024):
- 10,000 MAU free (Lite and Essentials tiers)
- Three tiers: Lite ($0.0055/MAU), Essentials ($0.015/MAU, the default), Plus ($0.02/MAU)
The cost at scale, using the Lite tier according to official Cognito pricing:
| MAU | Monthly Cost (Lite) | Monthly Cost (Essentials) |
|---|---|---|
| 10,000 | $0 | $0 |
| 50,000 | ~$220 | ~$600 |
| 100,000 | ~$495 | ~$1,350 |
| 500,000 | ~$2,475 | ~$7,350 |
For existing users, there’s a trap: user pools created before November 22, 2024 had the 50K free tier. Changing tiers drops you to the 10K free tier. For a 40K MAU app, that means going from $0/month to $220-$600/month.
One developer on Hacker News reacted:
“What the actual fuck AWS? Please don’t let this be a trend on AWS where we artificially gimp services just to create pricing tiers.”
But it gets worse. Rhythmic Technologies documented a new M2M (machine-to-machine) charge: $6/month per app client + $0.00225 per 1,000 token requests. For a 19-service microservices architecture, that’s $242.25/month ($3,000/year) in charges that didn’t exist before.
And there’s a subtle gotcha buried in the Cognito cost documentation: the AdminGetUser API operation marks users as active. A batch job querying your user pool can inflate your MAU count — and your bill.
AWS AppSync: The 20x Lambda Markup
Amplify uses AppSync for its GraphQL API layer. According to AppSync pricing:
- $4.00 per million query/mutation operations
- $2.00 per million real-time updates
- $0.08 per million minutes of connection time
Compare that to Lambda at $0.20 per million requests — AppSync is 20x more expensive on a per-request basis. For a read-heavy application making 10 million API calls per month, that’s $40/month on AppSync vs $2/month on Lambda with API Gateway.
The Serverless.com AppSync guide notes additional limitations:
“You don’t get access to performance settings for your GraphQL API layer. AppSync can add significant overhead to your API response times, and in certain cases you may not have data to debug increased latency.”
AppSync also has a 30-second timeout and 1 MB response limit — constraints that don’t exist with a self-hosted Apollo Server or Hasura.
DynamoDB: When the Access Pattern Changes
Amplify defaults to DynamoDB, a NoSQL database that requires you to know your access patterns upfront. In a Hacker News discussion, a developer discovered their Amplify app used only scan operations instead of queries, costing $15,000 annually and causing 10x slower page loads. Switching to secondary indexes fixed it — but Amplify had hidden this from them.
As one commenter put it:
“DynamoDB is amazing when you know all the access patterns… But if you have changing access patterns… DynamoDB is not for you.”
Sam Thorogood wrote a detailed critique explaining the fundamental problem: when Amplify’s @auth directive filters data, it can require fetching all records and filtering client-side. For 100,000 users each owning one row, that’s potentially 1,000 round trips from the browser to the database to find a single record.
When Convenience Becomes a Trap
The pricing abstractions create real financial damage. Here are documented cases.
Case 1: $1,124 From Following the Official Tutorial
Developer Elliott King published a detailed post-mortem after following the official Amplify guide for OpenSearch integration. His bill: $1,124.88 for a single month.
The root causes:
- The Amplify/CDK setup defaulted to
r5.large.searchOpenSearch instances at $0.186/hour (~$134/month each). The cheapert3.small.searchalternative costs $0.036/hour. - Running
npx ampx sandbox deletedid not delete the OpenSearch domains. - Restarting the sandbox created additional OpenSearch domains instead of reusing existing ones.
The Hacker News thread (200+ comments) revealed this wasn’t isolated:
“Billing alerts are a joke, give us hard spend limits. Then offer a way to set those limits during onboarding.”
“Building a business on blank cheques and accidental spends is shady and a large barrier to adoption.”
AWS issued a one-time courtesy credit. But the developer noted his normal Amplify usage was ~$50/month — the surprise came from services Amplify provisioned without clear cost warnings.
Case 2: $2,300/Month From a Stuck Deployment
A developer reported on GitHub that their side project had been running on Amplify at ~$40/month for years. After a deployment got stuck, the bill spiked to $900 the previous month and was projected at $2,300 for the current month ($889 already accrued at time of reporting).
Two AWS engineers spent two hours and could not resolve the stuck deployment. The developer eventually had to take a “nuclear” approach and manually delete AWS resources directly — a process Amplify’s own documentation warns against.
Case 3: No Hard Spending Cap
AWS does not offer a hard spending cap. AWS Budgets only sends alerts — it does not stop services. Without WAF ($22+/month), a traffic spike or DDoS attack generates data transfer charges with no ceiling.
“The scariest part about using Amplify is that because services are provisioned behind the scenes, there is the possibility of adding functionality that relies on a service with cost implications.”
Vendor Lock-in: The Most Expensive Cost
Vendor lock-in doesn’t appear on any invoice, but it may be Amplify’s highest cost.
Cognito Can’t Export Your Users’ Passwords
If you decide to leave Cognito, FusionAuth’s migration guide states it plainly:
“The first decision you’ll need to make is ‘Am I okay with forcing all my users to reset their passwords?’”
Cognito cannot export password hashes or MFA seeds. Your options are forcing a password reset on all users or maintaining dual systems indefinitely using Lambda-trigger-based just-in-time migration. For a 100K-user application, either option is expensive in engineering time and user friction.
CloudFormation’s 500-Resource Hard Cap
Amplify generates CloudFormation templates from your GraphQL schema. As your app grows, resolvers, IAM roles, and DynamoDB resources accumulate. A DEV.to post about migrating Amplify to CDK explains:
“Once approaching this threshold, adding new models or resolvers can fail” and “backend evolution effectively stalls.”
The official Amplify troubleshooting docs warn:
“Once an application is deployed to the cloud using Amplify CLI, the cloud resources like DynamoDB tables, Cognito Roles, or IAM policies must never be updated outside of Amplify CLI or Amplify Studio.”
Any manual change is an “unmanaged change” that can break deployments. You’re locked into Amplify’s tooling.
Gen 1 to Gen 2: AWS Can’t Even Migrate Itself
Amplify Gen 2 was a complete rewrite — TypeScript-first CDK definitions instead of CLI-driven configuration. The official migration guide says:
AWS is “actively developing migration tooling” called “Stack Refactor” but it’s not ready. Current advice: “continue working with your Gen 1 Amplify project.”
One Hacker News commenter summarized:
“The gen 1 to gen 2 migration docs are literally: just stay on gen 1.”
Gen 2 also dropped features: Gen 1 offered Auth, Analytics, API, DataStore, Geo, and Predictions. Gen 2 only has built-in Auth, Data, Storage, and Functions according to the official FAQ. Apps relying on DataStore’s offline-first capabilities have no migration path.
A developer who went through a Gen 1 to Gen 2 migration documented it on The Cloud Times, concluding that the migration required “substantial time and effort” — a few weeks of spare time for a medium-complexity backend.
Real Migration Stories
The migration costs are measured in weeks, not hours:
Healthcare startup (5+ engineers) — A team building an EHR system adopted Amplify in early 2020 and abandoned it in early 2021. Paul Foryt documented the experience:
“Once they had more than one engineer working on the backend code, simultaneous development became frustratingly difficult.”
Each engineer needed a separate Amplify environment, which “quickly increased AWS costs since each environment needed its own resources, including AppSync, ElasticSearch, DynamoDB, API Gateway, SQS queues, and a number of Lambdas.” HIPAA compliance was impossible because “certain settings changes required for HIPAA compliance weren’t exposed by Amplify.”
Peter Sereda’s team — An engineering team adopted Amplify for an internal automation portal. They documented a “loss of dozens and dozens of development man-days solely for struggling with Amplify: its bugs, instability, verbosity and boilerplate code.” Even 10 Lambda functions generated 200+ files and 40+ directories.
Reamplify project — The Reamplify team built an entire open-source tool to re-implement Amplify CLI in pure CDK, after “a frustrating week fighting a library bug” made them realize “the cost of re-implementing the Amplify CLI components with pure CDK was less than the cost of continuing to battle with the AWS Amplify CLI.”
Amplify vs. The Alternatives
How does Amplify’s total cost compare to the competition?
Free Tier Comparison
| Platform | Free Bandwidth | Free Build Minutes | Serverless | Storage |
|---|---|---|---|---|
| Cloudflare Pages | Unlimited | 500 builds/month | 100K Workers req/day | R2 10 GB |
| Vercel | 100 GB/month | Included | 100K invocations | KV, Postgres (limited) |
| Netlify | 100 GB/month | 300 min/month | 125K function calls | Limited |
| AWS Amplify | 15 GB/month | 1,000 min/month | Pay-as-you-go | 5 GB |
Amplify’s free bandwidth (15 GB) is 6-7x less than Vercel and Netlify, and infinitely less than Cloudflare.
Paid Tier Comparison
Based on data from Monetizely and Better Stack:
| Scale | AWS Amplify | Vercel Pro | Netlify Pro | Cloudflare |
|---|---|---|---|---|
| Personal/Hobby | Free-$5 | Free | Free | Free |
| Small Business | $30-70/month | $60-100/month | $57-95/month | Free-$25/month |
| Enterprise | $300-600+/month | $500+/month | $450+/month | Custom |
Amplify appears cheaper at medium scale, but this comparison only covers hosting. Add Cognito, AppSync, and DynamoDB, and the total cost changes dramatically.
The Cloudflare Factor
A developer who migrated from Amplify to Cloudflare Pages reported:
- Expected new cost: $0/month (entirely within free tier)
- Page load time improved from ~0.7s to 0.29s
- Primary motivation: eliminating “unlimited cost liability” and “runaway cost potential”
The Baselime case study is even more dramatic. They migrated their entire infrastructure from AWS to Cloudflare:
- Before: $708,100/year on AWS ($1,940/day)
- After: $118,625/year on Cloudflare ($325/day)
- Annual savings: $589,475 (83% reduction)
- Lambda $650/day → Workers $25/day (95% reduction)
- CloudFront $140/day → $0
- Migration took 3 engineers less than 3 months
When Amplify Actually Wins
It’s not all bad. An enterprise developer documented migrating FROM Vercel TO Amplify because Vercel’s costs “would scale exponentially with growth” and infrastructure costs were “already in the hundreds of thousands.” For teams already deep in the AWS ecosystem handling millions of transactions, Amplify’s pay-as-you-go model can be more predictable than Vercel’s per-seat pricing.
Verdict: When Amplify Makes Sense (and When It Doesn’t)
Use Amplify if…
- ✅ You’re already deep in the AWS ecosystem and your team knows IAM, CloudFormation, and the billing console
- ✅ You’re building a prototype or MVP where speed to market justifies the convenience tax
- ✅ Your project needs tight integration with AWS services (S3, Lambda, DynamoDB) that you’d use anyway
- ✅ Your traffic is low and predictable (within or near the free tier)
- ✅ You have AWS credits to burn (startup programs, etc.)
Don’t use Amplify if…
- ❌ You need predictable billing — there’s no spending cap
- ❌ You’re building something that might outgrow Amplify’s opinions (custom auth flows, complex queries, non-DynamoDB access patterns)
- ❌ Your app is bandwidth-heavy — the 67% data transfer markup compounds fast
- ❌ You need HIPAA, SOC2, or strict compliance where you need full control over infrastructure settings
- ❌ You might leave AWS someday — Cognito can’t export passwords, AppSync is proprietary, DynamoDB access patterns don’t transfer
Evaluate carefully if…
- ⚠️ You’re deploying SSR/Next.js — SSR adds Lambda@Edge compute costs with a 1 MB response limit and 25-distribution quota
- ⚠️ You have more than 10K monthly active users — Cognito costs jump from $0 to $220+/month
- ⚠️ You’re using Amplify Gen 1 — Gen 2 is the future, but there’s no migration path yet
Pre-Adoption Audit Checklist
Before choosing Amplify, answer these questions:
1. What will Amplify provision?
For each feature you enable (auth, API, storage, etc.), identify the underlying AWS service and its pricing. Use the AWS Pricing Calculator with your projected usage.
2. What’s your MAU projection?
At 10K MAU, Cognito is free. At 50K MAU, it’s $220-$600/month. At 100K, it’s $495-$1,350/month. Know where you’ll be in 12 months.
3. How much bandwidth will you use?
Calculate: users × average_page_size × visits_per_month. Every GB over 15 costs $0.15. At 1 TB/month, you’re paying $151 that would be free on CloudFront directly.
4. Can you set up billing alerts immediately?
As Be A Better Dev recommends:
“Set up a billing alert at a small dollar threshold ($5 or so).”
Do this before you deploy anything. AWS Budgets won’t stop spending, but at least you’ll know.
5. What’s your exit plan?
If you’re using Cognito, understand that user passwords can’t be exported. If you’re using AppSync, know that your GraphQL resolvers are AWS-proprietary. If you’re using DynamoDB, recognize that your data models are access-pattern-specific. Document your exit strategy before you need one.
6. Have you compared total cost?
Don’t compare Amplify hosting to Vercel hosting. Compare Amplify hosting + Cognito + AppSync + DynamoDB + Lambda to the equivalent full stack on alternatives. The hosting is the cheap part.
Key Takeaways
-
The pricing page shows hosting costs. The real bill comes from Cognito, AppSync, DynamoDB, and Lambda — services provisioned behind the scenes with their own pricing.
-
Amplify charges a convenience tax. 67% markup on data transfer, 5x on build minutes, and it doesn’t benefit from CloudFront’s free tier.
-
Cognito’s December 2024 restructuring hit hard. 80% free tier reduction, new M2M charges, and a default tier (Essentials) that’s 3x more expensive than Lite.
-
There’s no spending cap. AWS Budgets sends alerts but can’t stop services. Stuck deployments and orphaned resources generate bills silently.
-
Vendor lock-in is the hidden cost. Cognito can’t export passwords, AppSync is proprietary, DynamoDB access patterns don’t transfer, and even AWS can’t migrate Gen 1 to Gen 2 yet.
-
Amplify makes sense for some projects. If you’re already in AWS, building an MVP, or have credits to burn, the convenience can be worth the premium. But go in with eyes open.
The convenience is real. The costs are too. Know both before you deploy.