Cloud cost · Comparisons
Vercel vs AWS Cost at Scale: An API + DynamoDB Teardown
Serverless platforms bill every request, every gigabyte and every millisecond on its own meter. At launch those meters round to zero. At 100 million reads a day, the same API costs about five times more on Vercel than it does running next to its database in your own AWS account. This post prices one realistic workload, a Next.js API on Vercel that reads 5 KB items from Amazon DynamoDB, line by line from the public price lists. It shows where the gap opens, and which traps follow you into AWS as well.
By Jasdeep Bains, SeaGit
·
Key takeaways
- At 100 million DynamoDB reads a day, the API on Vercel costs about $11,950 a month at list prices. The same API on Amazon EKS next to the table costs about $2,400.
- The biggest line is not data transfer. CDN requests ($6,000) and function invocations ($1,800) are billed per request, and 3 billion requests a month is past every Flat Rate CDN tier.
- Vercel bills the same response bytes twice: Fast Origin Transfer from the function to the CDN ($0.06/GB), then Fast Data Transfer from the CDN to the user ($0.15/GB). How Fast Origin Transfer works.
- At 1 million reads a day both setups cost about the same, around $155 a month. The gap opens at about 5 million reads a day, when requests outgrow Flat Rate CDN.
- AWS has its own traps. Without the free DynamoDB gateway endpoint, NAT gateway processing adds about $640 a month for the same traffic.
The workload we priced
One read-heavy JSON API. Every request reads one item from DynamoDB and returns it to the browser. This is a common shape: product pages, user profiles, feeds and dashboards all look like it.
| Assumption | Value |
|---|---|
| Reads per day | 100 million (about 1,160 requests a second on average) |
| Requests per month | 3 billion (30 days) |
| Item size | 5 KB, returned to the client unchanged |
| Data per month | About 14.3 TB, read from the table and sent to users |
| DynamoDB mode | On-demand, strongly consistent reads (2 read request units per 5 KB item) |
| Region | US East: AWS us-east-1 and Vercel iad1 |
| Prices | Public list prices, checked on 17 November 2026. No discounts or commitments |
Two simplifications matter. We assume no CDN caching, because each response is per-user or changes often. We also assume about 3 ms of CPU per request for parsing, signing and serialising. Both are covered in the FAQ.
Where every request gets billed
On Vercel, one API request passes through several meters. All of these are on Vercel's own pricing pages for the iad1 region.
- CDN request: every request the CDN handles, $2.00 per million on demand. The Pro plan includes 1 million requests and 1 TB through Flat Rate CDN, and the largest flat tier ($300 a month) stops at 150 million requests. Above that, all usage moves to on-demand pricing.
- Function invocation: $0.60 per million.
- Active CPU: $0.128 per CPU-hour, billed only while your code runs, not while it waits for DynamoDB.
- Provisioned memory: $0.0106 per GB-hour for as long as a function instance is alive.
- Fast Origin Transfer: $0.06 per GB for the bytes moving between the CDN and your function, including the response the function returns.
- Fast Data Transfer: $0.15 per GB from the CDN to the visitor.
The last two are the double toll. Your 5 KB item leaves the function, and Vercel bills it as Fast Origin Transfer. It then leaves the CDN, and Vercel bills the same bytes again as Fast Data Transfer.
The hop between Vercel and DynamoDB
Vercel functions run in AWS regions, so where the function runs matters. AWS does not charge for data between DynamoDB and other AWS services in the same Region. Keep the function region and the table region the same and this hop costs nothing.
The trap is a mismatch. Vercel runs functions in iad1 (us-east-1) unless you change it. If your table lives in us-west-2 or eu-west-1, every byte crosses Regions at $0.02 per GB, about $286 a month here. Every read also waits tens of milliseconds longer.
If you put the project on Vercel Static IPs ($100 a month per project) or Secure Compute, usually to satisfy a database IP allowlist, Vercel also meters the function's own outbound traffic as Private Data Transfer. DynamoDB authenticates with IAM rather than IP addresses, so we leave that out.
Side by side: 100 million reads a day
The colocated column runs the same API as a container on Amazon EKS in the same Region as the table. It uses three m7g.large nodes behind an Application Load Balancer, and its private subnets reach DynamoDB through a gateway endpoint.
| Cost line | Vercel API + DynamoDB | API on EKS next to DynamoDB |
|---|---|---|
| DynamoDB reads (6 billion read units) | $750 | $750 |
| DynamoDB to API transfer | $0 same Region ($286 cross-Region) | $0 through the gateway endpoint |
| CDN requests (3 billion) | $6,000 | Not applicable |
| Function invocations (3 billion) | $1,800 | Not applicable |
| Active CPU (about 3 ms per request) | $320 | Not applicable |
| Provisioned memory | $77 | Not applicable |
| Fast Origin Transfer (14.3 TB) | $858 | Not applicable |
| Data out to users (14.3 TB) | $2,146 at $0.15/GB | $1,259 at AWS tiered rates |
| EKS control plane | Not applicable | $73 |
| Nodes (3 × m7g.large) | Not applicable | $179 |
| Application Load Balancer | Not applicable | $131 |
| Monthly total | about $11,950 | about $2,390 |
| Cost per million requests | $3.98 | $0.80 |
The colocated setup saves about $9,560 a month, or about $115,000 a year, at the same traffic. To run the same comparison for your own traffic, with SeaGit's seat fee and your team's engineering time included, use the Vercel vs AWS cost calculator.
Look at what drives the Vercel bill. Data transfer is about a quarter of it. Most of the rest is the per-request meters: CDN requests and invocations. They are invisible when you have thousands of users and dominate when you have millions. A container serving 1,160 requests a second has no per-request meter at all. You pay for the machine whether it serves ten requests or ten thousand.
How the gap opens as traffic grows
The same model at three traffic levels shows why this surprises teams. The decision is made at the first level and paid for at the third.
| Reads per day | Requests per month | Data per month | Vercel API | Colocated on EKS | Vercel per 1M requests | EKS per 1M requests |
|---|---|---|---|---|---|---|
| 1 million | 30 million | 143 GB | about $153 | about $156 | $5.09 | $5.19 |
| 10 million | 300 million | 1.4 TB | about $1,200 | about $415 | $4.01 | $1.38 |
| 100 million | 3 billion | 14.3 TB | about $11,950 | about $2,390 | $3.98 | $0.80 |
At 1 million reads a day the two are even. Vercel's $100 Flat Rate CDN tier covers requests and transfer, and the EKS cluster's fixed cost (control plane, two small nodes and a load balancer) is about the same. If your traffic stays there, pick whichever your team ships faster on.
Past about 5 million reads a day (150 million requests a month), the workload no longer fits any flat tier and every request is billed on demand. From there, Vercel's cost per million requests stays near $4 while the colocated cost per million keeps falling, because nodes and the load balancer grow much more slowly than traffic.
The traps that follow you into AWS
Moving the API into AWS is not automatically cheap. These are the line items that catch teams in their first month.
- NAT gateway processing. Pods in private subnets reach DynamoDB through the NAT gateway unless the VPC has a DynamoDB gateway endpoint. NAT processing is $0.045 per GB, about $644 a month for this workload. The gateway endpoint is free. Add it when you create the network; this guide shows how.
- Cross-Region reads. The API and the table must be in the same Region. Cross-Region transfer costs $0.02 per GB and adds latency to every read.
- Strong reads you do not need. A strongly consistent read of a 5 KB item costs 2 read units. An eventually consistent read costs 1. If your API can tolerate data a second old, that halves the DynamoDB line in both columns, from $750 to $375.
- A CDN in front of uncacheable responses. Putting CloudFront in front of an API whose responses cannot be cached adds per-request fees without saving any transfer. Use a CDN for what can be cached, and serve the rest straight from the load balancer.
- Idle capacity. Size nodes for your peak, but let the cluster autoscaler remove them when traffic falls. Fixed costs only beat per-request pricing when the machines are busy.
Split the frontend from the data path
You do not have to choose one platform for everything. The cheapest setup at scale usually splits by traffic shape:
- Keep pages and static assets where they ship best. Marketing pages and the app shell are cacheable. They hit flat tiers and rarely reach the per-request cliff.
- Move the high-volume data endpoints next to the data. Run them as a container in the same AWS account and Region as the table, at a subdomain such as
api.example.com. The browser calls it directly, so the bytes cross one meter instead of three. - Measure before and after. Vercel's usage dashboard shows Fast Origin Transfer and invocations per project. Sort by project to find the two or three routes that drive most of the bill. Those are the ones to move.
Five questions to answer before you choose a platform
- How many requests a month will the busiest endpoint serve in a year, not today?
- Which per-request meters apply, and where do the flat tiers stop?
- How many times are the same bytes billed between your database and the user?
- Is your compute in the same Region as your data, and does traffic reach the database without a NAT gateway?
- At your expected volume, what is the cost per million requests on each platform?
If you can't answer the last question, you can't predict the bill.
Where SeaGit fits
SeaGit deploys apps from GitHub pushes onto Amazon EKS clusters in your own AWS account. That puts the colocated column within reach without hand-building a platform:
- Your API runs next to your data. Pick the same Region as your DynamoDB tables, and data stays inside AWS.
- The free DynamoDB gateway endpoint is a checkbox on the network form, so pods do not send database traffic through NAT.
- AWS bills you directly, at list price or your negotiated rate, with your savings plans and credits applied.
- SeaGit charges a flat platform fee per seat. It does not grow per request or per gigabyte, so a traffic spike does not change it.
- Previews and promotion are built in. Every branch can get its own deployment and URL, and you choose when it becomes the main one.
SeaGit runs on AWS only today, on Amazon EKS. If your traffic is small and cacheable, a managed frontend platform may well be the simpler choice. Run the numbers in this post against your own traffic first.