Encoding cost and delivered quality are usually argued in two different meetings. Cost belongs to the infrastructure review; quality belongs to the player and QoE review. Nobody leaves either meeting holding a single model that trades one against the other, which is why ladder and codec decisions end up resting on a datasheet sentence — “AV1 is roughly 30% more efficient” — rather than on a number anyone measured on their own catalogue.
The model this article describes is deliberately small. Two axes: measured cost per encoded minute and per delivered stream on one, measured perceptual quality at each rung of the bitrate ladder on the other, with every rung weighted by the viewer device and network mix you actually serve. Build that surface before you argue about encoders. It changes which arguments are even available.
What does modelling transcoding cost vs delivered quality mean in practice?
It means refusing to let either axis be a property of the codec.
Cost is not “the GPU-hour rate” and quality is not “what the codec spec claims”. Both are functions of your content, your encoder settings, and your audience. A cost/quality model is the artefact that holds all three together, and its unit of analysis is the ladder rung — not the catalogue, not the codec, not the fleet.
The most useful property of the model is negative. Once each rung carries a measured cost and a measured, viewer-weighted quality contribution, some rungs turn out to cost money without reaching eyes. A model built from codec datasheets can only ever add rungs and call the extra encode cost quality. A model built from measurement can delete them. That asymmetry is the whole reason to build it.
A cost/quality model that includes viewer-weighting can justify deleting bitrate ladder rungs; a model built on codec efficiency figures alone structurally cannot, because it has no term for whether anyone watches the rung.
The inputs, and where each one comes from
Guessing an input is worse than omitting it, because a guessed number inherits the authority of the measured ones sitting next to it. Every cell below either has a source or is marked as an assumption in the model itself.
| Input | Source | Evidence class |
|---|---|---|
| Cost per encoded minute, per rung | Job-level instrumentation: wall-clock and GPU-seconds per job, output minutes per rendition | Operational measurement |
| Cost per delivered stream | CDN/egress logs joined to rendition identity, plus request volume from segmented HLS/DASH manifests | Operational measurement |
| Storage cost per rendition | Object-store billing by prefix, split by storage class and access frequency | Operational measurement |
| VMAF per rung | Offline scoring of a representative encode set against the source, per content type | Benchmark (named metric, your content) |
| PSNR per rung | Same encode set — retained only as a regression tripwire | Benchmark |
| Viewer device and network mix | Player telemetry: device class, negotiated rung, session duration, rebuffer events | Operational measurement |
| Encode-hours avoided | Modelled delta, stated as a projection until a validation encode confirms it | Projection, not measurement |
Two of these are commonly missing. Cost per encoded minute usually does not exist at rung granularity, because the invoice is blended across the fleet — that instrumentation gap is a prerequisite, and we treat it as work in its own right rather than as a rounding step. Rung-level viewership is the other; without it the weighting term is fiction and the model reverts to a datasheet argument in a spreadsheet costume.
Using VMAF as the quality axis, and PSNR as a tripwire
VMAF is the perceptual metric the model is anchored on because it correlates with what viewers report seeing, and because it is scored per rung against your own source material rather than against a reference clip somebody else chose. PSNR stays in the model for one job only: catching a regression in the encode chain that VMAF might mask.
Where each misleads:
- VMAF misleads when the model is wrong for the viewing condition. A score computed at 1080p reference viewing distance says little about a phone at 5 Mbps on a cellular link. Score per device class, or state which class the number belongs to.
- VMAF misleads on synthetic and high-motion content. Animation, screen content, and sport all move the curve. Segment the encode set by content type before averaging anything.
- PSNR misleads as a quality target. Optimising a preset to raise PSNR reliably produces encodes that look worse and cost more. It is a tripwire, not an objective.
- Both mislead as single numbers. A catalogue-mean VMAF hides the rung where the regression actually lands. Report the distribution, or at minimum the worst-served device class.
Content type and device mix determine how large the achievable gain is. The model’s job is to expose that dependency, not to average it away.
Weighting rungs by real viewers, not by codec claims
The weighting step is where the model earns its keep. Take each rung’s measured quality, multiply by the share of delivered minutes that rung actually serves, and you get a viewer-weighted quality contribution. Do the same for cost. Then read the two columns side by side.
A rung that carries 0.4% of delivered minutes and 9% of encode cost is a finance decision, not an engineering one. A rung that carries 31% of delivered minutes on the oldest hardware-decode-limited device class is untouchable regardless of what it does to the mean. Neither of those sentences is available to you without the weighting term.
The same arithmetic settles encoder choice without a hardware-preference argument. Put GPU and CPU encodes of the same rung set into the same table — achieved throughput on your content at your settings, resulting cost per encoded minute, and resulting VMAF at each rung — and the comparison becomes economic rather than tribal. Sibling work on when GPU transcoding actually beats CPU on unit cost covers the workload-shape variables that drive that particular comparison; here it is simply two more columns in the same model.
This modelling discipline sits under the broader argument about transcoding cost and quality in media and telecom delivery, where the ladder, the codec, and the fleet are treated as one decision rather than three.
Validate on a small encode set before touching the catalogue
A catalogue re-encode is the expensive failure mode this whole exercise exists to avoid committing to on intuition. So the model gets validated at small scale first, and the validation has a pass condition written down before it runs.
Validation checklist
- Select 20–40 assets spanning your real content types — including the awkward ones (animation, high-motion sport, screen capture, archive material with source artefacts).
- Encode the current ladder and the proposed ladder with identical packaging, identical segment duration, and identical filter chain. Only the variable under test moves.
- Score VMAF per rung per content type; record PSNR alongside purely as the regression check.
- Measure cost per encoded minute per rung from job-level instrumentation — GPU-seconds and wall-clock, not the fleet invoice divided by hours.
- Apply the viewer weights from player telemetry, per device class, using a recent window rather than an annual average.
- State the viewer-weighted VMAF delta and cost-per-stream delta as two numbers, with the worst-served device class named explicitly.
- Set the pass condition: no VMAF regression at the weighted device mix beyond an agreed threshold, and a cost-per-stream reduction large enough to survive being wrong by a factor you name.
- Only then authorise anything that touches the catalogue — and re-run steps 3–6 on the first production batch before proceeding to the rest.
Step 2 is where most validations quietly fail. Changing the ladder and the encoder preset in the same run gives you a delta you cannot attribute, and an unattributable delta is not evidence. The profiling-first discipline that governs this — change one variable, measure it, then move — is the same one we apply to inference workloads in our inference-cost audit methodology, transposed from inference to encode.
What the output looks like in a budget review
The deliverable is one table and one sentence. The table has rungs as rows; cost per encoded minute, cost per delivered stream, storage, VMAF per device class, and share of delivered minutes as columns. The sentence is the viewer-weighted delta: this change reduces cost per stream by X with no VMAF regression above Y at the measured device mix, and the worst-affected class is Z.
Measurable outcomes worth tracking after the change ships: ladder-rung count reduced without a VMAF regression at the weighted mix, cost per stream before and after, GPU utilisation across the transcoding fleet, and encode-hours avoided on rungs shown to carry negligible viewership. In our experience these four are enough to defend a ladder change to finance and to reverse it cleanly if the telemetry disagrees.
This model is the first artefact produced by a transcoding-scoped Inference Cost-Cut Pack, before any ranked optimisation roadmap gets written — because a roadmap without a cost/quality surface underneath it is a list of preferences.
The open question is how stable the weighting term is. Device populations shift, and a ladder tuned to last quarter’s mix is a ladder tuned to a moving target. How often the weights need re-measuring before the model starts lying is something we have not seen a general answer to — it appears to depend heavily on how fast the audience’s hardware turns over.
Frequently Asked Questions
What does modelling video transcoding cost vs delivered quality mean in practice?
Model Video Transcoding Cost is a frequent topic. It means holding both axes in one artefact at rung granularity: measured cost per encoded minute and per delivered stream against measured perceptual quality per rung, with each rung weighted by the share of delivered minutes it actually serves. Neither axis is treated as a codec property. The practical consequence is that the model can justify deleting rungs, which a datasheet-based argument cannot.
Which inputs does the model actually need, and how do you source each one without guessing?
Cost per encoded minute from job-level instrumentation (GPU-seconds, wall-clock, output minutes per rendition), cost per delivered stream from CDN and egress logs joined to rendition identity, storage cost from object-store billing split by class, VMAF and PSNR from offline scoring of a representative encode set, and the viewer device and network mix from player telemetry. Any input without a source is marked as an assumption inside the model rather than blended in silently.
How do you use VMAF and PSNR as decision metrics, and where does each one mislead you?
VMAF is the anchor because it tracks perceptual quality, but it must be scored per device class and per content type — animation, sport and screen content all move the curve, and a catalogue mean hides the rung where a regression lands. PSNR is retained only as a regression tripwire; optimising a preset to raise PSNR tends to produce encodes that look worse and cost more.
How do you weight bitrate ladder rungs by the real viewer device and network mix?
Multiply each rung’s measured quality and measured cost by the share of delivered minutes that rung serves, taken from player telemetry over a recent window rather than an annual average. Read the resulting cost and quality columns side by side per device class. A rung carrying a fraction of a percent of minutes and a large share of encode cost becomes a visible decision; without the weighting term it stays invisible.
How do you compare GPU and CPU transcoding inside the same model?
Add both as columns on the same rung rows: achieved throughput on your own content at your own settings, the resulting cost per encoded minute, and the resulting VMAF at each rung. Because both paths are scored on identical inputs and packaging, the encoder choice falls out of measured economics rather than a throughput headline or hardware preference.
How do you validate the model before authorising anything that touches the catalogue?
Run 20–40 assets spanning your real content types through the current and proposed configurations with identical packaging and filter chain, changing one variable at a time, then apply the viewer weights and state the cost and quality deltas with a pass condition agreed in advance. Re-check the first production batch before proceeding. A catalogue re-encode is the expensive failure mode the validation exists to prevent.
What does the model output look like as a checklist for a budget review?
One table — rungs as rows; cost per encoded minute, cost per delivered stream, storage, VMAF per device class, and share of delivered minutes as columns — plus one sentence stating the viewer-weighted cost and quality delta and naming the worst-affected device class. Post-ship tracking covers rung count, cost per stream, fleet GPU utilisation, and encode-hours avoided.
Quality targets dictate your transcoding bill
Every quality tier you add doubles the encoding workload, so start by challenging whether viewers can actually perceive the difference.
