A clean production build of PubTrivia takes 14.4 seconds on my laptop and prints a route table with no numbers in it at all. Next 16 dropped the Size and First Load JS columns, so the only way to find out what a build costs is to go and read .next yourself. I did that, page by page, and the thing I did not expect was a byte-identical duplicate of every page's data sitting next to the original.

The build, as it reports itself

▲ Next.js 16.2.7 (Turbopack) ✓ Compiled successfully in 6.5s Running TypeScript ... Finished TypeScript in 5.1s ... Collecting page data using 11 workers ... ✓ Generating static pages using 11 workers (156/156) in 636ms 

Then 136 route rows, each marked static or dynamic, and nothing else. No kilobytes anywhere. The whole output contains the word "size" zero times.

Route accounting

Count What
111 URLs in the live sitemap
136 rows marked static in the build table
138 routes in prerender-manifest.json
119 routes that produced an .html file
19 routes that produced a .body file instead
2 sitemap URLs that are not prerendered at all

The 19 with a .body and no HTML are the route handlers: fourteen social card images, robots.txt, sitemap.xml, manifest.webmanifest, the IndexNow key file and favicon.ico. Every one of them has "dataRoute": null in the manifest, which is the manifest's way of saying there is no React tree here to send a router.

The 27 static routes that are not in the sitemap are those handlers plus the pages we deliberately keep out of it: the four password reset screens, /maintenance, /too-many-requests, /subscribe/success, /_not-found and a development-only lab route. The two sitemap URLs with no HTML on disk are the homepage and /pricing, which are the only per-request pages on the site because they resolve the visitor's currency.

So: 109 prerendered sitemap pages, plus 10 prerendered pages nobody links to, plus 19 handlers, plus 2 functions.

What one page costs on disk

Take /faq. The build leaves this behind:

74,953 faq.html 38,390 faq.rsc 283 faq.meta 593 faq.segments/_tree.segment.rsc 2,953 faq.segments/_head.segment.rsc 3,465 faq.segments/_index.segment.rsc 38,390 faq.segments/_full.segment.rsc 367 faq.segments/faq.segment.rsc 30,565 faq.segments/faq/__PAGE__.segment.rsc 

The .meta is the response Next wants the CDN to send with it, and it names the segments:

{ "headers": { "x-nextjs-stale-time": "180", "x-nextjs-prerender": "1", "x-next-cache-tags": "_N_T_/layout,_N_T_/faq/layout,_N_T_/faq/page,_N_T_/faq" }, "segmentPaths": ["/_tree", "/_full", "/faq/__PAGE__", "/faq", "/_index", "/_head"] } 

Six segment files per route, on 118 of the 119. The exception is the global error page, which has five because it has no cluster segment above it.

Across all 119 routes:

Segment Files Total bytes Median
_full 119 4,428,796 37,688
__PAGE__ 119 3,459,368 29,472
_index 119 407,237 3,465
_head 119 352,545 2,996
cluster 225 88,195 367
_tree 119 79,044 677

The duplicate

Look again at /faq: faq.rsc and faq.segments/_full.segment.rsc are both 38,390 bytes. They are the same file:

$ md5 -q server/app/faq.rsc server/app/faq.segments/_full.segment.rsc 1d32701b733f15148939f3faca7d8cbd 1d32701b733f15148939f3faca7d8cbd 

I hashed all 119 pairs. 119 of 119 are byte-identical, and _full accounts for 4,428,796 bytes, which is exactly the total of the .rsc files. The build writes every page's flight payload twice under two names: once as the route's data response, once as the full-segment prefetch.

You can watch both come out of the CDN. The segment files are addressable from outside with one request header, and the numbers line up with the files on my disk:

$ curl -s -o /dev/null -w '%{size_download}\n' -H 'RSC: 1' \ -H 'Next-Router-Segment-Prefetch: /_tree' https://pub-trivia.app/faq 707 $ curl -s -o /dev/null -w '%{size_download}\n' -H 'RSC: 1' \ -H 'Next-Router-Segment-Prefetch: /_full' https://pub-trivia.app/faq 40697 $ curl -s -o /dev/null -w '%{size_download}\n' -H 'RSC: 1' https://pub-trivia.app/faq 40697 

The last two are the same response. Asking for /_full and asking for the page's data with no segment header at all return the same 40,697 bytes of text/x-component, which is the duplication on disk showing up as a fact about the live site. Every one of those responses carries vary: rsc, next-router-state-tree, next-router-prefetch, next-router-segment-prefetch, which is four cache keys for one page.

Live bytes run slightly above the disk bytes on every segment because the deployment id is stamped into every asset URL in the payload. I did not try to reconcile that difference to the byte.

The whole of server/app

Kind Bytes Files
.rsc 13,243,981 939
.json 9,486,819 977
.html 8,280,464 119
.js 3,296,841 345
.body 1,149,698 19
.meta 54,929 138
.map 9,169 173
Total 35,521,901 2,710

The flight data is 1.6 times the HTML it duplicates. And 977 JSON files is more JSON files than the site has pages.

8.4 MB of JSON to say the same thing 143 times

Of those 977 JSON files, the per-route manifests are mostly tiny: 173 build-manifest.json totalling 77,031 bytes, 173 app-paths-manifest.json at 12,620, 143 react-loadable-manifest.json at 286 bytes for all of them together.

Then there is page.js.nft.json: 143 files, 8,393,573 bytes. These are Vercel's file traces, the list of everything a route's server bundle needs. Summed, they hold 54,338 entries. Distinct, they name 2,517 files. So the average file is listed 21.6 times across the traces, because almost every route needs almost the same dependency closure.

The server's own trace, next-server.js.nft.json, is 128,734 bytes and names 705 files, 702 of which are inside node_modules/.pnpm.

Source maps, pointing the wrong way

JavaScript Source maps
.next/server 17,918,035 B in 1,039 files 68,738,008 B in 863 files
.next/static 3,580,972 B in 80 files 0 B in 0 files

68.7 MB of maps for code that never leaves the server, and none for the code that runs in a stranger's browser. I measured the client side of this from outside a while ago: request the .map beside any deployed chunk and you get a 403, because there is no map to serve. Convenient for not shipping our source, inconvenient the first time a user reports a stack trace.

What I cannot tell you from this

The build I read is my build, not the deployed one. Vercel builds from its own checkout and uploads whatever its build output manager decides to upload, so "the build writes 4.4 MB twice" is a claim about next build, not a claim about what sits in the CDN's origin store. The live segment responses above are the only part of this I could confirm from outside.

I also cannot tell you whether a browser ever asks for those .segments files on this site. The router's segment prefetching is what they exist for, and I had to send the header by hand to get one. Our pages reference 33 client chunks and no page ships a loading boundary on the public side, so a prefetch here tends to fetch whole pages rather than partial trees, which I measured separately a few weeks ago.

And the 14.4 second build is a warm build with a populated cache. A cold one on a fresh checkout is a different and larger number that I did not take, because taking it means deleting the cache I had just finished measuring for another post.

Worth fixing, in order of cheapness

Nothing here is a bug. The duplicate _full is Next's design, not a mistake in our code, and the traces are the price of serverless packaging. But two things are actionable for anybody reading their own .next: the per-route trace JSON is the biggest single thing in server/app after the payloads themselves, and server source maps are 19 times the size of the client bundle they do not describe. Both are configuration, not code.

If you want to see what all of that produces, the pages are at pub-trivia.app/features and pub-trivia.app/guides, and the five tools at pub-trivia.app/tools are the only ones with real client JavaScript doing anything. Running a quiz night is the free tier, no card, at pub-trivia.app.