Cost modelling: what your app will really cost at 10x and 100x

01

Why the bill surprises people

Almost nobody is surprised by the total. They are surprised by the composition - the line that was zero at launch and is now sixty percent of the invoice.

Three things cause it. Unit pricing rewards small volumes, so free tiers hide entire categories until you cross them and the first paid tier is nothing like a smooth continuation. Some quantities scale faster than users - log lines grow with requests, and requests grow with both users and features. And the bill is a lagging indicator: you see October's mistake in November, by which time it has been running for six weeks.

A model fixes this not by predicting the total accurately, which it will not, but by telling you which lever matters. You do not need to be right about the number. You need to be right about which line to watch.

02

The model, in four steps

1. 1

   Pick one demand driver

   Monthly active users for consumer, seats or accounts for B2B, documents or jobs processed for a pipeline product.

2. 2

   Derive the physical quantities

   Requests, database queries, gigabytes transferred, function seconds, log lines, stored bytes.

3. 3

   Price each line item at current list prices

   Record the price, the unit, the source and the date you checked.

4. 4

   Multiply, then hunt for the assumptions that break

   Free tiers you exceed, fixed floors that stop mattering, plan limits that force an upgrade, and anything you assumed was constant that is not.

03

Deriving the quantities

This is the chain that turns one number into a bill. The example column uses a thousand monthly active users and deliberately unremarkable multipliers.

Note the last row. Storage is the only quantity that accumulates: at steady traffic every other line is flat month to month and storage is a staircase. It is also the line people forget to model at all, because in year one it rounds to nothing.

04

The line items, one by one

Compute

Either a fixed price per machine per month or a metered price per unit of execution. The crossover matters: for steady traffic a rented machine is usually cheaper well before the point people expect, and for spiky traffic the opposite holds. Model both shapes rather than assuming.

Function invocations and GB-seconds

Charged twice - once per call, once for memory multiplied by duration. Raising a function's memory to fix a slow endpoint raises the second number proportionally, which is why performance work and cost work are the same work here.

Egress

Bytes leaving the provider, priced per gigabyte. Ingress is usually free, which is why nobody thinks about it. Cross-region and cross-zone traffic inside the same provider is also egress, and that surprises people more than the internet-facing kind.

Database

Compute plus storage plus, on some plans, input and output operations and backup storage. Read replicas duplicate the compute line. Point-in-time recovery adds storage proportional to write volume, not to database size.

Object storage

Cheap to store, priced per request to access, and expensive to move out. The store cost is not the problem; the egress and request lines attached to it are.

Logs, metrics and traces

Charged on ingestion per gigabyte and again on retention per gigabyte-month, and sometimes per host or per custom metric. This is the line that most often goes from free to largest.

Email, SMS and notifications

Per message, with a free tier that ends abruptly. Transactional volume tracks signups and activity, so it scales with the driver, and a retry loop can multiply it without any user doing anything.

Model and inference calls

Priced per token in and per token out, and capable of exceeding every other line combined. Context that grows with conversation length makes cost per request grow within a single session. Log token counts per request from day one or you will be unable to attribute anything.

Per-seat tooling and builder plans

Editors, collaborators, environments and sometimes preview deployments are priced per seat. This line grows with headcount rather than traffic, which makes it invisible in a traffic-based model unless you add it deliberately.

Your own time

The line item that never appears on an invoice. An hour a week of someone's attention on infrastructure is a real cost, and it is the one that decides whether a self-managed option is actually cheaper.

05

A worked example at 1x, 10x and 100x

The point of this table is not the totals. It is the reordering: at 1x the bill is mostly seats and a database, and at 100x it is mostly two line items that started at zero.

A hundred times the users produced roughly fifty-seven times the bill, because fixed floors and seat pricing do not scale with traffic. Cost per user fell, which is the shape you want. But logs went from nothing to nineteen percent of the invoice, and model calls to forty-one percent - and neither of those was in the original spreadsheet, because at 1x both were inside a free tier.

Put the result next to revenue. If the product charges twenty dollars a month and three percent of active users pay, a hundred thousand active users is three thousand customers and sixty thousand dollars of revenue against a seventy-three hundred dollar bill - about twelve percent. That is survivable. Above roughly a quarter of revenue, the model needs changing before the traffic arrives, not after.

06

The traps

Each of these has produced a bill that arrived with no corresponding change in the product. They are ordered by how often we see them.

Debug logging left on in production

The most common cost surprise we find. One verbose request log at two kilobytes across five million requests is ten gigabytes a month, charged on ingestion and again every month it is retained. Sample aggressively, set a retention policy, and log at debug level behind a flag.

Polling front ends

A component that refreshes every five seconds generates over seventeen thousand invocations per open tab per day. With per-invocation pricing, the polling interval is a pricing decision. Use a longer interval, a websocket, or server-sent events.

Media served without a CDN

User-uploaded images and video streamed directly out of object storage bills egress on every single view, with no caching between you and the viewer. Putting a CDN in front is often a same-day fix worth more than any code optimisation.

N+1 queries behind a list

A list of fifty items where each row fetches its own related record is fifty-one queries where one would do. It is invisible at demo size and it multiplies your database line by the page size.

Retries and webhook storms

A failing downstream turns one request into five, and every attempt is billed. Idempotency keys, exponential backoff and a circuit breaker are cost controls as much as reliability controls.

Free-tier cliffs

The tier above free is rarely a small step up. Model the tier above the one you expect to be on, and check whether the jump is triggered by usage or by a feature you are about to need.

Idle but provisioned

A staging database nobody uses, a forgotten preview environment, an unattached volume, a network gateway left from an experiment. Sort last month's bill by line and require a one-sentence justification for each.

Committing too early

Reserved capacity and committed-use discounts save a great deal at scale, and lock you to a size you chose while guessing. Commit only to the portion of usage you are confident is a floor.

Per-seat pricing on environments

Some builder and tooling plans count environments, preview deployments or collaborators as seats. Adding a contractor for a month can change three separate invoices.

07

Does moving pay for itself?

This is the only question a cost model needs to answer for a migration decision, and it needs to include the parts that do not appear on an invoice.

monthly_saving  = current_bill - (projected_bill + monthly_operational_hours * hourly_cost)
payback_months  = (migration_cost + internal_hours * hourly_cost) / monthly_saving

# Then run it again with the quantities from your 10x column.

• Payback under six months at today's volume: the cost case stands on its own.
• Payback between six and twelve months: defensible if growth is real, since the saving grows with the bill. Recompute at 10x before deciding.
• Payback over twelve months: migrate for control, capability or compliance if you need them - but do not claim it is a cost decision.
• Negative saving with the operational hours included: this is a control decision, and worth being honest about internally.

08

Controls to put in before you need them

• Every metered provider has a budget alert at a threshold you would want to be woken for.

  High

  Verify: Trigger one deliberately by lowering the threshold, and confirm it reaches a person rather than a shared inbox.

• Log retention is set explicitly, and debug-level logging is behind a flag.

  High

  Verify: Read the retention setting and the current monthly ingestion volume in your provider dashboard.

• Model calls have a per-user quota and a hard monthly ceiling, with token counts logged per request.

  Critical

  Verify: Query last week's logs for tokens per user and find your top consumer.

• Static assets and user media are served through a CDN with a sensible cache lifetime.

  Medium

  Verify: Request the same asset twice and confirm the second response is a cache hit.

• Someone owns a monthly bill review with the model open next to it.

  Medium

  Verify: Name the person and the recurring meeting. Thirty minutes a month is enough.

• Cost per active user is tracked as a number over time, not recalculated in a panic.

  Medium

  Verify: Show the last three months of the figure and explain any month that moved more than twenty percent.

The spreadsheet, if you want the shape

A. Drivers      MAU, sessions/MAU, pages/session, requests/page,
                queries/request, KB/page, log lines/request, uploads/user
B. Prices       one row per line item: unit, price, source URL, date checked
C. Quantities   formulas only, derived from tab A
D. Bill         quantities x prices, with a separate column for fixed floors
E. Scenarios    1x / 10x / 100x as columns, everything driven by tab A

Rule: only tabs A and B are typed by hand. If a number is typed into
tab D, the model is no longer a model.