Introducing per-second billing for every instance type

Effective today, everywhere

Every Reviosa instance type — every GPU, every CPU shape, every bare-metal configuration — now bills by the second, with a 60-second minimum per run. No new SKUs, no opt-in flag, no pricing changes. The hourly rates you already know ($2.49 for an H100, $18.32 for an 8×H100 node, $3.69 for an H200, $0.69 for an L40S) simply meter at 1/3600th granularity. It applies automatically to every instance launched from today, on-demand and reserved-overage alike.

Why we did it

Hourly billing was designed for a world of long-lived servers. Modern ML workloads don't look like that. They look like a CI pipeline that grabs a node for nine minutes to smoke-test a training script. An eval sweep that needs an H100 for twenty minutes after every merge. An autoscaler that adds an inference replica for the lunch-hour spike and drops it at 1:30. Under hourly billing, every one of those rounds up — and teams responded rationally by batching work awkwardly, holding instances "just in case," and building scheduling complexity whose only purpose was dodging the rounding.

That is engineering effort spent on our meter instead of your product. So we fixed the meter.

The math

What common short-lived workloads now cost:

• 9-minute CI smoke test, 8×H100 node ($18.32/hr): 540 seconds → $2.75. Previously billed as a full hour: $18.32.
• 22-minute eval sweep, single H100 ($2.49/hr): 1,320 seconds → $0.91.
• 4-minute canary replica, L40S ($0.69/hr): 240 seconds → $0.05.
• 35-minute fine-tune debug session, H200 ($3.69/hr): 2,100 seconds → $2.15.

For bursty workloads we studied while designing this change, the effective savings ranged from 15% to over 60% — with zero change to how the workload runs. Long-running training jobs and steady inference fleets are unaffected: an instance that runs for days costs exactly what it did before. And because rates are unchanged, there is no catch to look for — the same $2.49 H100 hour simply divides into 3,600 honest pieces.

What it changes about how you build

Once partial hours stop rounding up, some good architectural habits stop costing money:

• Scale inference to actual traffic. Add and remove replicas on real demand curves instead of hourly boundaries; the autoscaler no longer needs to be smarter than the billing system.
• Run sweeps as many short jobs. Twenty 15-minute hyperparameter trials now cost the same as one 5-hour block — so parallelize freely and get answers in an afternoon.
• Give CI real GPUs. Testing the actual training path on the actual hardware for minutes at a time is now cheap enough to run on every merge.
• Kill idle instances without ceremony. The "we already paid for the hour" instinct is obsolete. Stop means stop paying — within a second.

The details

• Granularity: one second, 60-second minimum per instance run.
• Coverage: all instance types, all regions, on-demand and reserved-overage usage.
• Visibility: the dashboard and API now report accrued cost live, and invoices itemize each run to the second — what started, when, for how long, at what rate.
• Action required: none. It is already on. Instances launched before today finish their current billing period on the old meter and switch automatically at the next start.

What's next

Per-second billing is the foundation for work we will ship over the coming quarters: finer-grained autoscaling hooks, budget alerts that act in seconds rather than at invoice time, and scheduled capacity that starts and stops itself. The principle behind all of it is the same one behind today's change: you should pay for exactly the compute you use — measured honestly, displayed live, and never rounded in our favor.