The Real Cost of a Production Stack on AWS in 2026: ECS Fargate, RDS, NAT Gateways, and Unified Cloud Alternatives

Contents
Every migration conversation we have starts the same way: someone pastes an AWS bill into the chat and asks whether the number is normal. It is normal. That is the uncomfortable part. Nothing on the bill is a mistake, every line is published pricing, and the total still surprises the person paying it, because the units AWS sells are smaller than the units startups think in.
So we priced a real stack instead of arguing adjectives. The reference workload is deliberately ordinary: a web API, a background worker, a cron job, a 20 GB PostgreSQL database and 100 GB of monthly egress. Every rate below comes from AWS’s own pricing pages and price files for US East (N. Virginia), checked on 7 November 2026, and the arithmetic is shown so you can swap in your own shapes. We run the same exercise for our own platform at the end, including the lines where we lose.
The reference stack, line by line
| Line | Sizing | Rate | Monthly |
|---|---|---|---|
| Web API on Fargate | 1 vCPU, 2 GB, always on | $0.0405/vCPU-hr + $0.00445/GB-hr | $36.04 |
| Worker on Fargate | 0.5 vCPU, 1 GB, always on | same | $18.02 |
| Cron on Fargate | 0.5 vCPU, 0.5 GB, 30 hrs | same | $0.67 |
| Database on RDS for PostgreSQL | db.m6g.large, Single-AZ | $0.159/hr | $116.07 |
| NAT gateway | one, always provisioned | $0.045/hr + $0.045/GB processed | $37.35 |
| Application Load Balancer | one | $0.0225/hr + $0.008/LCU-hr | $16.43 + LCUs |
| Data transfer out | 100 GB to the internet | $0.09/GB | $9.00 |
| Total | ≈ $234 + LCU usage + RDS storage |
The Fargate rates come straight from AWS’s own worked example on the pricing page: $0.000011244 per vCPU-second and $0.000001235 per GB-second, Linux/X86. The db.m6g.large figure is from AWS’s public RDS PostgreSQL price file. And the total is a floor, not a ceiling. It assumes one AZ, no read replica, no Multi-AZ (which roughly doubles the database lines), no CloudWatch, no public IPv4 addresses at $0.005/hour each, and RDS storage billed separately at gp3 rates. A team that enables the boring reliability defaults most guides recommend will see something past $350 for this same five-service shape.
The fixed-cost tax
The compute lines above behave the way you expect: they scale with the workload. The two lines that do not are the ones that generate the migration emails.
The NAT gateway costs $0.045 for every hour it exists, which is $32.85 in a 730-hour month, plus $0.045 for every GB processed through it, plus the standard data transfer charge on top. AWS’s own pricing page is explicit that the hourly charge “will always apply once the NAT gateway is provisioned and available”. A regional NAT gateway spanning three AZs bills the hourly rate three times. The load balancer beside it is $0.0225 per hour, $16.43 a month, plus LCU usage. Together that is roughly $49 of monthly network furniture for a stack that could fit on one machine, payable at 3 a.m. on a Sunday with zero requests in flight.
To be fair to AWS, both lines are avoidable with work: the VPC pricing page itself documents gateway endpoints as the way to keep S3 traffic off the NAT, a single NAT in one AZ serves a small fleet, and a service that only receives inbound traffic behind a CDN may not need an ALB per service. The tax is the price of assembling infrastructure from parts, and the assembly is your job, which is the part the sticker price never shows.
The database lines hide the most
RDS PostgreSQL on a db.m6g.large is $116 a month Single-AZ before storage, and Multi-AZ doubles the compute. That is a fine product at a knowable price. The surprises live in the two serverless-shaped options around it.
Aurora Serverless v2 bills $0.12 per ACU-hour on Aurora Standard in US East, from the worked example on the Aurora pricing page, with storage at $0.10 per GB-month and I/O at $0.20 per million requests unless you choose the I/O-Optimized configuration at $0.156 per ACU-hour. The old floor was 0.5 ACU, about $43.80 a month for a database that could be doing nothing. AWS has since added auto-pause to zero ACUs, and it works, with a resume in roughly 15 seconds. Read the blockers before you budget around it: “If any user-initiated connections are open to an Aurora serverless instance, the instance won’t pause.” A standing connection pool, which is what every production app framework opens by default, defeats auto-pause completely. So do RDS Proxy, logical replication, global databases and zero-ETL integrations.
The quieter trap is Extended Support. When an engine version passes end of standard support and you have not upgraded, RDS bills a per-vCPU surcharge on top of the instance price. AWS’s own example: an Aurora PostgreSQL 12 instance in US East (Ohio) pays “$0.100 per vCPU-hr between March 1, 2025 to February 28, 2027”, doubling to $0.200 after. On a 2-vCPU instance that is $1,752 a year for the privilege of not having upgraded yet, and it applies to every running instance including replicas. Nobody plans this line into the budget. It appears.
Fargate versus App Runner, and versus the PaaS field
AWS sells two container shapes, and teams often compare the wrong pair. App Runner is the managed one: $0.064 per vCPU-hour while active, plus $0.007 per GB-hour for provisioned memory that keeps your service warm, which by design never fully idles to zero on a live service. Fargate is cheaper per unit and gives you the assembly kit. Against the PaaS field the honest comparison is shape, not rate:
| AWS App Runner | AWS Fargate | Render | Fly.io | Scalix Run | |
|---|---|---|---|---|---|
| 1 vCPU / 2 GB always on | ≈ $57 | ≈ $36 | $25 flat | $33 (performance-1x) | $32.12 |
| Bill when idle | provisioned memory keeps metering | task runs, task bills | full flat rate | rootfs storage only if stopped | nothing if min instances = 0 |
| Load balancing / TLS | included | assemble (ALB, certs) | included | included | included |
| Network furniture | VPC connector, egress paths | NAT + ALB typical | none | none | none |
| Managed Postgres beside it | RDS, separate meter | RDS, separate meter | first party, from $19/mo | first party, from $38/mo | first party, same key |
Render and Fly rates from render.com/pricing and fly.io pricing docs, checked the same day. The App Runner figure is 730 hours of 1 vCPU at $0.064 plus 2 GB of provisioned memory at $0.007, which is the always-warm shape AWS documents.
Where AWS genuinely wins
This is the section a teardown owes you, because the fixed-cost tax is not the whole story. AWS runs the most regions of anyone, which decides it the moment latency or data residency in a specific market is the requirement. The compliance surface is deeper than any challenger’s, and procurement teams know how to buy it. Savings Plans cut compute up to roughly 50% against a one or three year commitment, and at fleet scale the fixed network costs amortise across hundreds of services instead of five. If your data platform, identity and streaming already live there, moving two containers out to save $49 a month does not pencil. The escape math only works when the whole five-service shape can leave together.
What the same stack costs elsewhere
We priced this exact reference stack across six platforms, line by line, in app hosting in 2026. The totals, with the caveats in that post: about $234 on AWS, $125 list on Vercel Pro plus Neon for the request-driven shape (and a third vendor for the always-on worker), $109 on Render Pro, $109 on Railway Pro, $85 on Fly, and about $73 in pure usage on Scalix.
Ours, fullest, since it is our platform: the web API and worker meter per second at $0.036/vCPU-hour and $0.004/GiB-hour with a minimum instance count you can set to zero, the database is Scalix Nova at $0.0954 per CU-hour with compute suspending when idle and storage at $0.315 per GB-month, and there are no NAT, ALB or platform-fee lines because the gateway, TLS, DNS and load balancing are the platform rather than products beside it. The rates are the published price book, the same manifest the console meters against. What we do not have: one EU region today with India next, a 4 vCPU ceiling per service, no support tiers or contractual SLA, and a seven-month operating history against AWS’s two decades. If any of those is decisive for you, the honest move is to stay where you are.
Cut the AWS bill without migrating
Half of the teams reading this cannot leave this quarter, and the useful answer for them is not a competitor list. In rough order of impact: stop dev and staging RDS instances instead of idling them, or move them to Aurora Serverless v2 with a real 0 ACU minimum and no connection pool in the way; right-size against CloudWatch metrics rather than the instance you provisioned during an incident; route S3 and DynamoDB traffic through gateway endpoints, which AWS documents as the way to drop the NAT processing charge; consolidate to one NAT gateway per region unless the availability math genuinely demands three; buy a Compute Savings Plan once the usage floor is visible, not before; and audit engine versions for Extended Support exposure, because that surcharge is pure waste by definition. None of this is exotic. It is just the assembly work, in reverse.
What actually moves in a migration
More than teams fear, less than vendors claim. Container images are OCI artifacts and run unchanged on Fargate, Render, Fly, Railway or our platform. PostgreSQL leaves RDS the way it leaves anywhere: pg_dump and pg_restore, or logical replication for a short cutover, no proprietary format on either side. What does not move is the glue: IAM roles become per-platform API keys, VPC and security-group topology becomes the platform’s default network model (on ours, per-workload network isolation with no VPC to design), and CloudWatch dashboards get rebuilt wherever your observability lands. Budget the glue, not the database.
One more line belongs in any 2026 version of this teardown, and it is not about price. AWS is a US operator, so the CLOUD Act applies to data it holds regardless of which region the disk sits in. For most workloads that is a non-event. For the growing set of teams whose procurement asks the question, we keep the cited primary-source version in our sovereign cloud research, and it applies to every US-operated platform in the comparison above, including us only in the negative: Scalix World is operated by European and Indian companies with no US parent.
If you want to run the numbers on your own shape rather than ours, the reference stack in this post is the method: list your services, multiply by published rates, and add every line that bills while you sleep. The pricing page renders our rate manifest live if you want to price the same stack against us, and we would rather you did the math than believed ours. Bring the result to Discord and we will check it with you.
FAQ
How much does a production stack cost on AWS per month?
For a small but real stack, one always-on 1 vCPU/2 GB web API on Fargate, a 0.5 vCPU worker, an hourly cron, a db.m6g.large PostgreSQL database and 100 GB of egress, the us-east-1 list prices checked on 7 November 2026 add up to about $234 per month. That excludes RDS storage, ALB LCU usage, Multi-AZ, CloudWatch and public IPv4 charges, all of which are separate meters.
How much does an AWS NAT gateway cost?
$0.045 per hour it exists, which is $32.85 over a 730-hour month, plus $0.045 per GB processed, plus the standard data transfer charge on whatever leaves through it. A regional NAT gateway spanning three availability zones bills the hourly rate per AZ. None of it scales down with your traffic; the hourly charge applies whenever the gateway is provisioned.
Is AWS Fargate more expensive than Render?
Per unit of compute, they are close: Fargate bills about $0.0405 per vCPU-hour plus $0.00445 per GB-hour in us-east-1, and Render's 1 CPU/2 GB instance is a flat $25 per month, which is roughly $0.034 per hour all-in. The gap is what surrounds them: Fargate needs an ALB, usually a NAT gateway and a VPC layout you assemble, while Render's price includes the load balancing, TLS and CDN. At one or two services Render is cheaper; at fleet scale with committed-use discounts AWS can win. Model your own shape rather than trusting either headline.
How do I reduce my AWS RDS bill?
In order of typical impact: stop or snapshot dev and staging instances instead of leaving them running, right-size instances against actual CPU and memory metrics rather than fear, consider Aurora Serverless v2 with a true 0 ACU minimum if your workload genuinely idles and has no connection pool keeping it awake, buy a Database Savings Plan once usage is steady, and check whether you are on an engine version paying Extended Support, because that per-vCPU surcharge can exceed the instance price.
Does Aurora Serverless v2 scale to zero?
Yes, since AWS added auto-pause at a 0 ACU minimum capacity, with an idle timeout configurable from 5 minutes to a day and a resume time of roughly 15 seconds. The documented blockers matter more than the feature: any open user connection prevents pausing, so a standing connection pool defeats it, and RDS Proxy, logical or binlog replication, global databases and zero-ETL integrations also keep instances awake. Engine version minimums apply.
What is an AWS ECS or Fargate alternative for startups?
The honest answer depends on what pulls you to leave. For a flat predictable bill with managed Postgres beside the service, Render and Railway are the usual shortlist. For direct VM lifecycle control with wide region reach, Fly.io. For a unified platform where containers, Postgres, storage, auth and inference share one key, one ledger and no NAT or load balancer line items, that is what we built Scalix Cloud to be, with the caveat that we run one EU region today against AWS's global footprint.