Cost-aware design

Cost-aware design treats the cloud bill as a non-functional requirement, like latency or availability. You estimate what a design will cost per month and per unit of business value, find the line item that dominates, and make the trade-offs between cost, speed, resilience and engineering time explicit, instead of discovering them on the invoice.

Picture it first: the cloud kitchen’s monthly statement

You run a cloud kitchen in Bengaluru. Every morning you check the price of cooking gas, because the stove is what you can see burning. Then the monthly statement arrives, and gas is 6% of it. The biggest line is the delivery fee, charged per kilometre on every order that leaves. Next comes the walk-in freezer, still full of sauces from last Diwali, then the CCTV recorder that keeps every minute from every camera.

Two lessons follow. The total tells you little: a bill that doubled in festival week is fine if orders tripled, so watch cost per order. And you cannot cut what you have not measured; the stove was never the problem.

Map it back: the stove is compute, the per-kilometre fee is data transfer, the freezer is storage nobody moved to a cheaper shelf, the CCTV is logging, and cost per order is unit cost.

Cost is a design requirement

Most cost is decided in the design review, not the billing console. Where the database sits relative to its callers, whether images are resized before serving, how long logs are kept, how many services one request crosses: each sets a per-request price you then pay millions of times, and changing it later means migrating data and code.

Unit cost beats the total bill

A total tells you whether you can afford the system; a unit cost tells you whether the design is any good. Pick a denominator the business already counts:

• Per transaction: cost per 1,000 UPI-style payments, or per order.
• Per request: cost per million API calls, for platform teams.
• Per user: cost per monthly or daily active user, for consumer apps.
• Per GB stored or per stream-hour, for storage and media products.

During a Flipkart-style sale the bill may jump fivefold for two days. Fine, if cost per order stays flat; if it rises, something scales worse than linearly, such as a chatty service or an over-eager log level.

What the frameworks say

The AWS Well-Architected cost pillar has five design principles: build cloud financial management as a capability, like security; adopt a consumption model (stopping dev and test stacks outside the 40 hours a week they are used saves about 75%); measure business output against cost; stop paying for undifferentiated heavy lifting; and attribute spend to its owners.

The FinOps Foundation runs the practice as a repeating cycle. Inform: allocate spend to owners and compute unit economics. Optimize: split into usage optimisation (use less: right-size, delete, re-architect; an engineering job) and rate optimisation (pay less per unit through commitments and discounts, with procurement). Operate: make the changes and build the habits. Design interviews are mostly about usage, the part architecture controls.

The cost drivers, and how to estimate each

Every bill breaks down into a handful of meters. Prices here are list prices for US East (N. Virginia) at the time of writing, with 1 TB counted as 1,000 GB. Regions differ (S3 Standard is $0.025 per GB-month in Mumbai), prices change and large customers negotiate, so check the pricing page before quoting one. These are plenty to find the dominant driver.

Compute

Instances bill by the hour or second, busy or idle. An m7g.xlarge (4 vCPU, 16 GiB) is $0.1632 an hour on demand, and a month is about 730 hours: 0.1632 × 730 ≈ $119 a month. Two discounts change that:

• Savings Plans trade a 1- or 3-year commitment to spend so many dollars an hour for a lower rate: up to 66% off with flexible Compute Savings Plans, up to 72% with EC2 Instance Savings Plans tied to one family and region. For this instance, a 1-year no-upfront Compute plan is $0.1199 an hour (27% off). Reserved Instances are the older form of the same deal.
• Spot sells spare capacity at up to 90% off, but EC2 can reclaim it with two minutes’ notice. When this was written, Spot for this type was about $0.091 an hour, 44% off.

Storage

Object storage is priced per GB-month, and the S3 class moves the price more than twentyfold:

A petabyte in Standard is 50 TB × $0.023 + 450 TB × $0.022 + 500 TB × $0.021 ≈ $21,550 a month, every month. Block storage under a database costs far more: RDS gp3 is $0.115 per GB-month, five times S3 Standard, and double that for Multi-AZ, one reason blobs in the database (monolithic persistence) hurt.

Requests

Many services charge per call. S3 charges $0.005 per 1,000 PUTs and $0.0004 per 1,000 GETs. DynamoDB on demand charges $0.625 per million writes in 1 KB units, so a 10 KB item costs ten units per write. Lambda charges $0.20 per million invocations plus $0.0000166667 per GB-second, billed per millisecond. Requests rarely dominate until you write a billion tiny objects (1B × $0.005 / 1,000 = $5,000) or call once per event instead of once per batch.

Data transfer

Bytes hold the surprises, because the price depends on where they go:

• In from the internet: free.
• Out to the internet: $0.09 per GB for the first 10 TB a month, then $0.085, $0.07 and $0.05. 100 TB a month is 10k × 0.09 + 40k × 0.085 + 50k × 0.07 ≈ $7,800.
• Between Availability Zones: $0.01 per GB in each direction, so $0.02 for every GB that crosses.
• Between regions: $0.02 per GB sent from US East to most regions.
• Through a NAT gateway: $0.045 per GB processed, whatever the destination, plus $0.045 an hour per gateway. A gateway endpoint for S3 or DynamoDB is free and takes that traffic off the NAT.
• To a CDN: origin fetches into CloudFront from AWS origins are free; viewers cost $0.085 per GB in North America after a free first terabyte, less at volume.

Managed services, logs and people

Managed services charge a premium for work you stop doing. RDS for PostgreSQL on a db.r7g.xlarge is $0.478 an hour against $0.2142 for the same-size EC2 instance, and Multi-AZ doubles it to $0.956. Managed, highly available Postgres is 0.956 × 730 ≈ $698 a month against 2 × 0.2142 × 730 ≈ $313 for two self-run instances: a $385 premium.

Whether that is expensive depends on people, the line missing from the cloud bill. At an assumed $10,000 a month per engineer (use your own number), an engineer-day is about $450, so one day a month of patching, failover drills and upgrades eats the premium.

Logs grow with traffic times verbosity. CloudWatch Logs charges $0.50 per GB ingested, so 2 KB of logs per request at 1,000 requests a second (2 MB/s × 2.63M s ≈ 5.3 TB a month) costs $2,630, more than twenty m7g.xlarge instances.

A worked estimate: a photo-sharing app

State assumptions, price each line, divide by volume, rank. Take version 1 of a photo-sharing app: one region, two AZs, all on demand, nothing tuned:

• 1 million daily active users, each viewing 50 photos a day at 150 KB: 1M × 50 × 150 KB = 7.5 TB a day, 225 TB a month from 1.5 billion views.
• 200,000 uploads a day: a 2 MB original plus 0.5 MB of resized copies, 15 TB a month; after two years, 360 TB stored.
• 100 million API calls a day: about 1,160 a second on average, 3,000 at peak.

Divide by the business: $32,832 ÷ 1M ≈ 3.3 cents per daily user a month, or $32,832 ÷ 1.5M ≈ 2.2 cents per 1,000 photo views.

Read the shares. Delivery and storage are 73% of the bill; compute, the thing teams instinctively tune, is 6%. A 30% cut in compute saves $556; in delivery, $4,700.

Five changes, and what each one costs

1. Shrink the bytes, then add a CDN (saves $4,070). Serving WebP or AVIF sized for each screen takes the average photo from 150 KB to, say, 100 KB: 150 TB a month. Through CloudFront: 10k × 0.085 + 40k × 0.080 + 100k × 0.060 = $10,050, plus 1.5B HTTPS requests at $0.01 per 10,000 = $1,500. At a 95% hit ratio S3 serves 75M GETs ($30); origin fetches are free. Delivery: $11,580. The CDN alone, still at 225 TB, would come to about $14,580, saving barely $1,070: smaller bytes did most of the work. You pay: CPU to transcode each upload, more stored variants, purges on delete. Lower latency comes free; see content delivery network.

2. Let originals cool (saves $4,765). Originals are rarely opened after the first weeks, so a lifecycle rule moves them to Glacier Instant Retrieval at 30 days. Resized copies stay in Standard, because thumbnails under 128 KB would be billed as 128 KB. Standard keeps 84 TB (72 TB of copies plus this month’s 12 TB of originals): 50k × 0.023 + 34k × 0.022 = $1,898. Glacier IR holds 276 TB: 276k × 0.004 = $1,104. Add 6M transitions at $0.02 per 1,000 ($120), reading back 1% a month (2.76 TB × $0.03 = $83) and the PUTs: $3,325. You pay: retrieval fees if access changes; a “memories” feature that resurfaces old originals would flip this maths.

3. Right-size and commit (saves $851). Autoscale the API between 4 and 14 instances, 8 on average. A 1-year Compute Savings Plan covers the 4 that never go away (4 × 0.1199 × 730 = $350); the other 4 run on demand ($477). The resizers pull from a queue, so they move to Spot: 4 × 0.0599 × 730 = $175. Compute: $1,002. You pay: a year’s commitment, and resizers that re-queue work on a two-minute warning.

4. Log less (saves $2,430). Keep every warning and error (10% of volume, 600 GB) and sample 10% of the rest (540 GB): 1,140 GB × $0.50 = $570. You pay: one particular successful request may be missing; keep trace IDs and count with metrics (observability).

5. Fix the network paths (saves $1,355). An S3 gateway endpoint takes the resizers’ traffic off the NAT (20 TB processed becomes 1 TB: $99 + $45 = $144), and zone-aware routing keeps service calls in their own AZ (40 TB crossing becomes 15 TB: $300). Network: $444. You pay: uneven load across zones, and routing that must still fail over.

The new bill is 11,580 + 3,325 + 570 + 2,440 + 1,002 + 444 = $19,361: 41% less, 1.9 cents per daily user. The database never moved; a cache absorbing most feed reads could retire the replica ($813 a month) at the price of a cache tier and invalidation (no caching).

Levers and what each one costs

Every lever trades cost for latency, availability, flexibility or engineering time. Say both halves.

Commit to the floor, not the average

A Savings Plan is a promise to spend so many dollars an hour, used or not. For an m7g.xlarge a committed hour is $0.1199 against $0.1632 on demand, so one more committed instance pays off only if it is busy more than 0.1199 ÷ 0.1632 ≈ 73% of the hours.

This fleet averages about 20 instances and never drops below 10. All on demand it costs 19.85 × 730 × $0.1632 ≈ $2,365 a month. Commit to the floor of 10: about $2,049. Commit to the average of 20 and 17% of the committed hours sit idle overnight: $2,144, worse than the floor. Buy commitments after autoscaling and right-sizing, or you lock today’s waste in for years.

Serverless or always-on: find the break-even

Pay-per-request pricing wins when traffic is low or spiky, since idle costs nothing, and loses at steady load, since every call carries a premium. A handler with 512 MB and 100 ms average duration costs 0.5 GB × 0.1 s × $0.0000166667 ≈ $0.00000083 of compute plus $0.0000002 per request: about $1.03 per million. A steady R requests a second is R × 2.63M a month, so Lambda costs about $2.72 × R.

Two m7g.xlarge instances, the minimum for two AZs, cost $238 a month; at about 10 ms of CPU per request, each serves around 200 requests a second at 50% CPU. Break-even: 238 ÷ 2.72 ≈ 88 requests a second, about 231 million a month.

The front door moves the line: an API Gateway HTTP API at $1.00 per million roughly doubles the serverless cost, so break-even falls to about 45 requests a second. Spiky traffic moves it the other way, because containers must be sized for the peak, and people time favours serverless. Serverless architecture covers the rest; the habit is to compute the crossover rather than argue about it.

Let data cool: tiers and retention

Most data is read heavily for days, then hardly at all. A lifecycle rule moves it down the tiers as it ages; an expiry rule deletes what you will never need, the cheapest tier of all.

Three rules make tiering pay. Move only large objects: the colder classes bill anything under 128 KB as 128 KB, and S3 skips small objects in lifecycle transitions by default. Move only data that stays cold longer than the minimum stay: delete a Deep Archive object after 30 days and you still pay for 180. And price the reads: a feature that starts reading old data turns retrieval fees into the biggest line. The photo app’s rule targets large originals only:

{
  "Rules": [
    {
      "ID": "originals-cool-down",
      "Status": "Enabled",
      "Filter": { "And": { "Prefix": "originals/", "ObjectSizeGreaterThan": 1048576 } },
      "Transitions": [{ "Days": 30, "StorageClass": "GLACIER_IR" }],
      "NoncurrentVersionExpiration": { "NoncurrentDays": 30 }
    }
  ]
}

Redundancy is a cost you choose

Availability is bought with copies. Multi-AZ RDS doubles the instance price; a service across three AZs keeps a third of its capacity spare for losing a zone; a hot standby region roughly doubles the bill and adds $0.02 per GB replicated. Often the right purchase, but a purchase: set targets from what downtime costs the business (disaster recovery), and go multi-region only for a reason one region can’t meet (multi-region and active-active).

Making cost visible

You can’t manage a number nobody sees. Six habits make engineers react to cost the way they react to latency:

• Tag and allocate. Every resource carries team, service and env tags, enforced at creation; on AWS they reach billing reports only once activated as cost allocation tags. Agree how to split shared costs such as NAT and logging, for example by request share.
• Showback, then chargeback. Showback sends each team its bill; chargeback moves it into their budget. Visibility changes behaviour before accounting does.
• Budgets and anomaly alerts at 50%, 80% and 100% of forecast, plus anomaly detection for sudden jumps: a debug log level left on, a runaway autoscaler, a retry loop hammering S3.
• Unit cost next to latency: cost per 1,000 requests beside p99 and error rate, per service, daily, so a deploy that doubles log volume shows up the next morning.
• A cost section in every design doc: monthly and unit cost at launch and at 10× scale, the top driver, and what you would cut first.
• Cost as a fitness function: an automated check, such as CI estimating the cost change of an infrastructure diff, or an alert when unit cost rises 20% week on week.

With billing data exported and tagged, unit cost is one query (simplified tables):

SELECT c.usage_date,
       c.team,
       SUM(c.cost_usd)                                        AS cost_usd,
       m.orders,
       ROUND(1000 * SUM(c.cost_usd) / NULLIF(m.orders, 0), 2) AS usd_per_1k_orders
FROM   billing_daily  AS c
JOIN   business_daily AS m ON m.usage_date = c.usage_date
WHERE  c.usage_date >= CURRENT_DATE - INTERVAL '30 days'
GROUP  BY c.usage_date, c.team, m.orders
ORDER  BY c.usage_date, usd_per_1k_orders DESC;

Going deeper: traps and surprises

Optimising the wrong thing

Engineer time is usually the dearest resource. At the assumed $10,000 a month, a two-week project costs about $4,600, so saving $200 a month takes 23 months to pay back. Spend effort where the bill is; the photo app’s compute was 6% of it.

Egress and NAT surprises

The classic shock: private subnets reach S3 through a NAT gateway, and a pipeline moving 100 TB a month pays 100,000 GB × $0.045 = $4,500 to process traffic a free gateway endpoint would carry. Its cousins: a service mesh whose calls hop zones, and container images pulled through the NAT on every scale-out.

Idle resources and over-provisioned floors

Weekend dev stacks, forgotten load-test clusters, unattached volumes and old snapshots all bill by the hour. Floors hide waste too. An IRCTC-style booking service that keeps 40 instances all day for the 10 am tatkal rush pays for 30 idle ones for 23 hours: 30 × 23 × $0.1632 × 30 days ≈ $3,400 a month that a scheduled scale-up at 9:45 would avoid. The opposite trap is no maximum: 200 runaway instances cost $32.64 an hour, about $1,960 over a weekend. Set the max from the budget as well as from what dependencies survive (autoscaling done right).

Logging explosions and replication bills

A log level switched to DEBUG during an incident and never switched back can multiply ingestion tenfold overnight, so alert on log bytes per request. Cross-region replication bills twice: $0.02 per GB sent, plus a second stored copy. Replicating 10 TB of new photos a month costs $200 in transfer and adds $230 a month of storage, and the storage keeps accumulating.

Spot and commitment traps

Spot capacity can vanish with two minutes’ notice, and AWS advises against it for stateful, inflexible or fault-intolerant work: checkpoint and re-queue rather than hope. Commitments cut the other way. A 3-year Instance plan bought just before a move to another instance family or to serverless leaves you paying for unused hours; Compute Savings Plans follow you across families and to Fargate and Lambda.

When the architecture is the cost

In 2023 Prime Video’s video-quality team described a stream-monitoring service built on AWS Step Functions and Lambda, with video frames passed between components through S3. Two costs dominated: Step Functions charges per state transition, and the workflow made several for every second of every stream; and the many S3 calls for frames were expensive. It also hit a scaling limit at about 5% of the expected load. Moving everything into one process on ECS kept frames in memory, cut infrastructure cost by over 90%, and opened the door to compute Savings Plans.

It became a headline about monoliths, but the team’s own conclusion was “case by case”: serverless suited building quickly and stopped fitting once the design multiplied per-transition and per-request prices by thousands of streams. The right architecture depends on the workload.

Cheat sheet

How to say it in the interview

“I treat cost as a requirement with a number. I estimate the bill line by line: instance hours, GB-months by storage class, requests, and bytes moved, split into egress, cross-AZ and NAT, because per-GB prices tend to dominate. Then I divide by volume: here about $33k a month, 3.3 cents per daily user. Half is photo delivery, so I’d serve right-sized modern formats through a CDN, move old originals to Glacier Instant Retrieval, sample success logs and add an S3 gateway endpoint. Compute is 6%: autoscale it, commit to the floor, resizers on Spot. Each change has a price, like retrieval fees if old photos get popular.”

How would you estimate the cost of a design you’ve just drawn? List the meters, price each with the arithmetic shown, rank them, then divide by a business unit such as orders or daily users so designs can be compared.

What usually dominates? For media apps, delivery bytes and storage. For chatty microservices, cross-AZ traffic, NAT processing and logs. Compute is often smaller than people expect.

Serverless or containers for this API? Compute the break-even. A 512 MB, 100 ms handler costs about $1 per million requests on Lambda, so two always-on instances at $238 a month win above about 88 steady requests a second. Below that, or when traffic is spiky, serverless wins on cost and on people time.

When is an optimisation not worth it? When the engineering cost exceeds the saving over the system’s life, or it gives away reliability the business needs. A $200-a-month saving that costs two engineer-weeks takes about two years to pay back.

How do you stop cost from creeping back? Tag everything, show each team its unit cost beside its latency, alert on budgets and anomalies, and add a check that fails when unit cost jumps.

Where to go next

• Back-of-envelope estimation: the traffic and storage arithmetic every estimate starts from.
• Numbers to know: latencies and sizes to pair with these prices.
• Autoscaling done right: floors, maxima and the lag that sets your headroom.
• Content delivery network: hit ratios, cache keys and purges.
• No caching and monolithic persistence: shrinking the database.
• Serverless architecture: where pay-per-request fits.
• Observability: cutting telemetry volume without going blind.
• Disaster recovery and multi-region and active-active: what redundancy costs.
• Scalability and vertical vs horizontal scaling: how cost grows with the system.

References and further reading

1. AWS Well-Architected Framework, Cost Optimization Pillar: Design principlesdocs.aws.amazon.comThe five principles, including the consumption model with its 40-of-168-hours (75%) dev and test example, measuring efficiency and attributing spend.
2. FinOps Foundation: FinOps Framework phasesfinops.orgThe Inform, Optimize and Operate cycle, unit economics in Inform, and the split between usage optimisation (engineering) and rate optimisation (procurement).
3. Amazon EC2 On-Demand pricingaws.amazon.comInstance hourly rates, internet egress tiers from $0.09 per GB, free inbound transfer, and cross-AZ transfer at $0.01 per GB in each direction.
4. Best practices for Amazon EC2 Spotdocs.aws.amazon.comSavings of up to 90%, the two-minute interruption notice, and which workloads suit Spot and which do not.
5. Compute Savings Plans pricingaws.amazon.comUp to 66% off with Compute Savings Plans and up to 72% with EC2 Instance Savings Plans, charged on the hourly commitment whether used or not.
6. Amazon S3 pricingaws.amazon.comPer GB-month prices by storage class, request and retrieval fees, the 128 KB minimum billable size and the 30, 90 and 180-day minimum storage durations.
7. AWS Lambda pricingaws.amazon.com$0.20 per million requests, $0.0000166667 per GB-second on x86, 1 ms billing granularity and the monthly free tier.
8. Amazon VPC pricingaws.amazon.comNAT gateway hourly and per-GB processing charges, applied whatever the traffic’s source or destination, on top of normal data transfer.
9. Amazon CloudFront pay-as-you-go pricingaws.amazon.comPer-GB delivery tiers by viewer region, HTTPS request fees, the free tier, and free origin fetches from AWS origins.
10. Scaling up the Prime Video audio/video monitoring service and reducing costs by 90% (Prime Video Tech, 2023, archived)web.archive.orgA Step Functions and Lambda pipeline that passed frames through S3, rebuilt as one process on ECS: over 90% lower infrastructure cost, and the team’s case-by-case conclusion.