Build1 distinct publisher3 min readPublished
Prefill and decode sit on the same card and answer to different limits, which is why a GPU with more arithmetic and the same memory read rate leaves your time per output token exactly where it was.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Time per output token comes out of a division [10]. The numerator is the bytes the card has to read to run one pass: the full weights, 16 GB in the post's example, plus the notes and the word just produced [9][8]. The denominator is how fast the card can read its own memory [11]. Core count does not appear anywhere in that expression [18]. Fit a card with more arithmetic and the same memory read rate, and each decode lap lands at the same moment it did before, which is exactly the case the dev.to post flags as a faster GPU making no difference at all [16].
The toy example makes the volume visible. "The capital is Paris" is four laps [14]. Each lap moves the whole 16 GB of weights out of VRAM and past the cores, which glance at it and do a small amount of maths [9]. Four laps at 16 GB is 64 GB of reads to write four words [15]. Most of the card is watching.
Prefill runs the other way round. The whole prompt goes through in one pass with thousands of cores firing together [3], and the length of the pause is set by how much text you handed over: six words vanishes, a hundred-page contract is tens of thousands of tokens and the pause is real [6]. That makes a published TTFT a statement about somebody's prompt length. For the number to transfer to you, your prompt token count has to match theirs; otherwise the table has told you about their document [19].
The reason each decode lap stays cheap is the notes. Every word produced is appended to the KV cache, so lap three does not re-read your prompt plus the first two words, and if it did, every single word would carry its own pause [13]. Those notes are written into the same VRAM that already holds the weights [4][20]. So a long context costs capacity that the weights have claimed, and it adds bytes that every subsequent lap has to read [8].
That is the whole argument for reading a card as two specs rather than one. In my context, mostly long inputs and short structured outputs, prefill dominates the wall clock and arithmetic throughput is the thing I would pay for. Flip the traffic to short prompts and long answers and the same purchase buys idle cores, because the loop is then bounded by memory reads for its entire duration [11]. The ratio of prompt tokens to output tokens in your own logs decides which of those two situations you are in, and no spec sheet knows it.
Ranked by verification strength, evidence, and original report placement.
How long the prefill pause lasts depends entirely on how much text was given to read: six words would not be noticed, while a hundred-page contract is tens of thousands of tokens pushed through in one burst and the pause is real.
In the traced example the answer takes four laps of the decode loop: "The", "capital", "is", "Paris".
The post says knowing the two phases explains why a faster GPU sometimes makes no difference at all.
A single LLM request contains two phases that run on two different parts of the same GPU and are limited by two different bottlenecks.
The model server loads the model's weights into VRAM at startup and they stay there; nothing about an incoming request loads a model.
Prefill reads the entire prompt at once rather than word by word: all tokens go to the cores together in a single pass, with thousands of cores firing simultaneously.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 30, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
Four concurrent MPS processes fill the L40S that one ASR request leaves 80% idle1 distinct publisher
build
SGLang's one-GPU Qwen3.8-27B recipe is the useful half of the release1 distinct publisher
build
Unsloth's 10% quant claim is really about which machines can run a 27B model1 distinct publisher
build
AWS moves KubeRay chores into HyperPod, and the build-vs-buy math with them1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
One explainer, two spec sheets
The mechanism is described consistently and the numbers that matter are traceable — 48 GB and 864 GB/s from NVIDIA's L40S datasheet, 28 billion parameters at one byte each under FP8 — but every load-carrying statement rests on one author's exposition, with no measurement, no profile trace and no second publisher. The strongest passage is the decode walkthrough, which is exactly the passage nobody in our coverage has checked.
Nothing to count yet
No release, deployment, pricing move or benchmark run appears anywhere in this reporting. An instance type is named as a worked example and a datasheet is quoted; neither tells us that anyone has run this configuration, so there is nothing here to score.
Sober mechanics, brisk arithmetic
For most of its length the piece under-sells rather than over-sells: no product, no benchmark victory, just a request being traced. The overreach sits in one line — 'Two numbers off two spec sheets, and you know roughly how fast that model will generate on that card. No deployment required.' A single-request model on an idle GPU using peak rather than achieved bandwidth gives you a ceiling, not a forecast, and the confidence of the framing runs slightly ahead of that.
An AWS-shaped worked example
Low stakes, but not zero: the post appears under an AWS solutions-architect handle and, when the argument needs a reference card, the card arrives as an AWS g6e.xlarge rather than a bare L40S. Nothing is being sold and the physics does not bend for the vendor — the visible tilt is which catalogue the example is drawn from.
Right mechanism, loose numbers
We hold the prefill/decode split, the KV cache's role and the memory-bound nature of decode with reasonable confidence — these are well-established and the exposition is internally coherent. Confidence drops on the numbers: the illustrative weight size shifts mid-argument, the model name is garbled, and there is a single publisher, so any arithmetic error travels unchallenged.