The App Router makes you choose, per file, which side of the network a component runs on. Most writing about that choice is advice. This is an audit of what the choice looks like after a year of shipping: Nakodo is 582 TypeScript files and 72,683 lines, and 80 of those files carry "use client".
Where the 80 live
app/(app) 35 the signed-in product components/ui 17 shadcn primitives app/(marketing) 4 public pages app/admin 4 components/brand 3 app/(auth) 3 components/support 2 components/illo 2 components/analytics 2 hooks 2 components (singletons) 4 turnstile, save-first, local-time, content/copy-button lib 2 toast.tsx, clipboard.ts Those 80 files are 14,043 lines, 19.3% of the codebase. The other 80.7% never ships to a browser.
The number I did not expect: exactly one of the 80 is a route file, and it is an error boundary.
$ grep -rl '"use client"' src | grep -E 'page|layout|loading|error|not-found' src/app/(app)/error.tsx React requires error boundaries to be client components, so that one is not a choice. Every one of the 53 page.tsx files and all 7 layout.tsx files is a server component. The boundary is always drawn below the route, never at it.
What the boundary looks like in practice
The widest boundary in the app is the campaign results screen. A server page runs seven queries in parallel and hands the result to a client component as props:
export default async function CampaignResultsPage({ params }: PageProps<"/campaigns/[id]">) { const { id } = await params; const { user, campaign } = await requireCampaign(id); const [rows, allowance, progress, inReview, day, dry, upgrade] = await Promise.all([...]); return <ResultsView campaignId={id} kind={campaign.kind} rows={rows} ... />; } ResultsView is 1,153 lines, the largest client file in the repo, and it takes 13 props. Across all 83 exported client components the median is 3 props and the maximum is 16, on the campaign brief editor. No client component takes zero props, which is another way of saying none of them fetch their own data.
That is the whole pattern, and it has one cost and one benefit. The cost is prop plumbing: when a filter in a client component needs one more number, the number has to be loaded in the page and threaded down. The benefit is that no loading state exists for data that the server already had, and nothing in the client bundle knows how to query a database.
25 of the 80 have no state at all
client files with no hook of any kind: 25 22 of them are shadcn primitives (dialog, select, sheet, tabs, tooltip, ...) 3 are ours: content/copy-button.tsx, lib/clipboard.ts, lib/toast.tsx A file with no hooks still needs the directive when it uses context, a ref forwarded by a library, or a DOM API. This is the quiet half of "use client": it does not mark "this is interactive", it marks "this module must be in the browser graph".
Ten client files import the database schema
This looked wrong when the grep returned it:
src/app/(app)/settings/plan/switcher.tsx: import type { PlanId } from "@/db/schema"; src/app/(app)/campaigns/targeting-fields.tsx: import type { BusinessTargeting, CampaignLocation } from "@/db/schema"; src/app/(app)/campaigns/new/flow.tsx: import type { BusinessTargeting } from "@/db/schema"; src/app/admin/users/[id]/forms.tsx: import type { PlanId } from "@/db/schema"; Every one is import type, so nothing survives compilation and no Drizzle code reaches the browser. It works because our schema module imports nothing but leaves, a rule that also explains why nine of our eleven import cycles pass through that one file and every one of them is type-only. The payoff is that a plan id or a targeting shape is defined once, in the table that stores it, and a client form can name that type without a parallel copy.
32 of the 80 import a Server Action, which is the other direction across the boundary: a function reference that becomes a POST.
How much of a public page is actually interactive
The code census says 12 client files can reach a public page. The live measurement is better. React leaves its props on the DOM node under a __reactProps$ key, so you can count, after hydration, exactly which elements carry an event handler:
for (const el of document.querySelectorAll("*")) { const key = Object.keys(el).find((k) => k.startsWith("__reactProps$")); if (!key) continue; const handlers = Object.keys(el[key]).filter((k) => /^on[A-Z]/.test(k) && typeof el[key][k] === "function"); } | Page | Elements | With handlers | <a> | <button> | Other |
|---|---|---|---|---|---|
| /glossary | 793 | 86 | 85 | 1 | 0 |
| /pricing | 1,051 | 46 | 45 | 1 | 0 |
| /guides/how-to-find-youtube-influencers | 932 | 57 | 56 | 1 | 0 |
| /blog | 671 | 51 | 50 | 1 | 0 |
| /tools/engagement-rate-calculator | 893 | 79 | 54 | 5 | 20 |
| / | 1,478 | 70 | 52 | 11 | 7 |
On four of those six pages, the entire interactive surface is links plus one button. The links are not ours: onClick, onMouseEnter and onTouchStart on 85 anchors is Next's <Link> wiring up prefetch on hover and touch. The single button is the mobile menu trigger:
<button data-slot="button" data-variant="ghost" data-size="icon" aria-label="Menu"> The calculator page adds what you would expect from a calculator: ten inputs with onChange, ten labels, five buttons. The home page adds eleven buttons, which are the tour that walks through the example card.
The FAQ accordions on 66 pages contribute nothing to this count, because they are <details> elements and need no JavaScript at all.
What I take from this
- "Server components by default" is not a slogan here, it is a measurable 80.7% of the code and four fifths of every public page having no handlers on it.
- The one client route file in the app is the one React forces. That is a good test to run on your own repo: if a
page.tsxhas the directive, something below it probably wanted it instead. - The two largest client components, at 1,153 and 860 lines, are both editors, and both are large because a form with interdependent fields genuinely is client state. They are also the two files I would split first, and the boundary audit is what made that obvious: they are not big because of the boundary, they are big because nobody has split them.
Everything in the table is checkable in your own browser console on any page of our site.


