Inference Founder // Field Course
0% completeCourse brief

Lesson 04 / 07 · II · Build

Benchmark the promise and the business

Turn performance into goodput, cost, and a result a skeptical buyer can reproduce.

Founder decision
Never sell tokens per second without a workload, quality floor, and latency SLO.
Target time
7 min briefing + 60–120 min fieldwork
Evidence
4 primary / first-party records
Before the answer: Name three ways a provider can make a tokens-per-second chart look impressive without improving your user's experience.

NARRATED · CAPTIONED · PRECISE ENGINEER

Narrated visual briefing

Benchmark the promise and the business

01 · Benchmark contractFreeze the rules before the race
02 · GoodputCount work that actually succeeds
03 · Unit economicsPrice the successful token
04 · Worked exampleThe cheapest GPU can produce the costliest request
05 · Claim disciplineA speedup is bounded by quality and regime
Benchmark contract

A credible inference benchmark begins with a contract. Freeze the model revision, tokenizer, precision, quantization, prompt corpus, output cap, decoding settings, hardware, runtime version, batching policy, cache state, concurrency pattern, quality metric, and latency objective. MLPerf's enduring discipline is to measure defined workloads against accuracy targets. Without that discipline, two providers can report impressive numbers while running different tasks. The benchmark is not a chart. It is a reproducible experimental boundary.

Goodput

Make goodput your north-star system metric. Goodput counts requests that meet both the quality floor and the latency service objective. Peak tokens per second can rise while time to first token deteriorates, tail latency explodes, or users time out. Report time to first token at multiple percentiles, inter-token latency, total request latency, tokens per GPU second, errors, and goodput. Run a matrix across prompt lengths, output lengths, concurrency levels, and cache conditions. One number cannot describe an inference system.

Unit economics

Calculate cost per successful million tokens, not cost at theoretical peak. Start with GPU hourly cost divided by effective tokens per GPU second and by thirty-six hundred, then multiply by one million. Effective throughput uses achieved utilization, not benchmark utilization. Add CPU, storage, network, failed requests, cold starts, support burden, and reserved headroom. Baseten's live retail prices are a comparison point, not your cost structure. Record the date because prices and hardware change quickly.

Worked example

Work a deliberately illustrative example. Suppose a GPU costs six dollars and fifty cents per hour and reaches fourteen hundred output tokens per second in a warm peak test. If representative traffic achieves only fifty-five percent utilization, effective throughput is seven hundred seventy tokens per second before failures. The compute-only cost per million output tokens is then the hourly price divided by effective tokens per second and thirty-six hundred, multiplied by one million. But if fifteen percent of requests miss the service objective and are retried or abandoned, cost per successful token rises again. Add CPU, storage, network, observability, and warm headroom. Now compare two configurations: one may show lower peak throughput yet higher goodput because its queue remains stable. The numbers here are not a market price claim; replace every input with a dated measurement. The lesson is the shape of the calculation: utilization, success, and overhead decide the business, not the most flattering microbenchmark.

Claim discipline

Read breakthrough claims with disciplined curiosity. Taalas reports extraordinary output speed and cost and power advantages for a hard-wired Llama, while also acknowledging quality degradation from aggressive early quantization. The correct response is to reproduce the workload boundary, compare task quality, and identify applications where the speed changes user value. Publish your own corpus, commands, versions, raw results, percentiles, failures, quality result, and assumptions. A rerunnable benchmark is technical proof and sales collateral at the same time.

WORKING MODEL

Four ideas to carry

Goodput, not peak throughput

Count requests that meet quality and latency targets. Saturating a GPU while users time out is not success.

A matrix, not one number

Vary input/output length, concurrency, cache reuse, model/quantization, and GPU. Report distributions.

Quality is a constraint

Quantization and speculative methods can change outputs. Compare accuracy or task success before speed.

Economics include idle and failure

Use achieved utilization, cold starts, retries, support, and reserved capacity—not peak benchmark utilization.

REFERENCE

The benchmark contract

Freeze these before running: model revision, tokenizer, precision, quantization, prompt corpus, output cap, decoding settings, hardware, runtime version, batching policy, cache state, concurrency pattern, quality metric, and SLO. MLPerf's central discipline is that performance is measured against defined workloads and accuracy targets.E10

MetricWhat it revealsHow it lies
TTFT p50/p95/p99Queue + prefill responsivenessWarm cache, short prompts, low concurrency
Inter-token latencyStreaming smoothnessAverages hide stalls
Output tokens/sec/userSingle-stream generation paceCan ignore aggregate efficiency
Tokens/sec/GPUCapacity efficiencyCan ignore user latency
GoodputRequests meeting quality + SLOOnly honest if the SLO is external
Cost/successful 1M tokensBusiness realityMust include idle, failures, and overhead

Core equations

goodput = successful_requests_meeting_SLO / second

effective_tokens_per_gpu_second = measured_tokens_per_second × achieved_utilization

compute_COGS_per_1M = gpu_hourly_cost / effective_tokens_per_gpu_second / 3600 × 1,000,000

gross_margin = 1 − total_variable_COGS / revenue

Baseten's live pricing page is a useful retail reference, not your eventual cost base.E7 Record the retrieval date and make the calculator editable. Your true COGS adds CPU, storage, networking, failed requests, support burden, and idle headroom.

Read Taalas claims correctly

Taalas reports an extreme output-rate result and large cost/power advantages on its hard-wired Llama. The same page discloses quality degradation from aggressive first-generation quantization.E2 The intellectually honest response is neither belief nor dismissal: reproduce the workload boundary, compare quality, and ask which applications convert the speed into user or agent value.

Your benchmark report

Publish the corpus description, command, versions, raw results, percentile charts, quality result, failures, and cost assumptions. State what you did not test. A benchmark that a design partner can rerun is both product work and sales collateral.

SHIP EVIDENCE

Produce Benchmark Report 0.1

Use the load generator and unit economics calculator. Run at least four concurrency levels, two prompt shapes, warm and cold cache, then write a one-page conclusion with the best and worst regime.

Course artifact: labs/benchmark.py

DIAGNOSTIC CHECKS

Can you use the model?

CHECK 1 · discrimination

Which is the most buyer-relevant primary metric?

CHECK 2 · application

What must accompany an aggressive quantization speedup?

CHECK 3 · transfer

Which cost input is most likely to make a prototype model unrealistically optimistic?

EVIDENCE LEDGER

Sources and limits

Vendor performance and product claims are labeled as first-party. Prices and product surfaces can change; follow the live links before making a purchasing or fundraising decision.

  1. ev-taalas-results The path to ubiquitous AI · Taalas
    Taalas reports 17,000 tokens per second per user on a hard-wired Llama 3.1 8B, nearly 10 times its comparison baseline, with lower build cost and power. It also acknowledges quality degradation from aggressive three-bit and six-bit quantization in its first generation.
  2. ev-baseten-scaling Autoscaling · Baseten
    Baseten documents scale-to-zero, min and max replicas, concurrency targets, utilization thresholds, autoscaling windows, and scale-down delays. It explicitly frames higher concurrency as lower cost with more queueing, and lower concurrency as higher cost with less queueing.
  3. ev-baseten-pricing Cloud pricing · Baseten
    Baseten lists pay-as-you-go dedicated GPU deployment prices by minute and offers scale-to-zero. Its July 2026 page lists H100 and B200 instances alongside smaller GPUs, while enterprise plans add self-hosting, custom SLAs, security controls, and use of existing cloud commitments. Prices are volatile; consult the live page.
  4. ev-mlperf-method MLPerf Inference Benchmark Suite · MLCommons
    MLPerf Inference measures system performance across multiple deployment scenarios while pairing performance with defined models, datasets, and accuracy targets. The 2026 suite includes datacenter and edge workloads for several language, vision, recommendation, and speech models.