Server time is where most "the app is slow" reports actually live, and it has only a handful of causes: you waited for data serially, you fetched more than you render, you serialised it all into the payload, or you missed the cache. Each has a lever, and one of them has a rule attached that interviewers listen for.

Know

• Waterfalls. Sequential await useAsyncData(...) calls in setup add up. Start them without awaiting and await Promise.all([...]), or mark non-critical ones lazy: true so navigation is not blocked.
• Over-fetching. pick and transform shrink what enters the payload; deep: false (the default in Nuxt 4) avoids deep reactivity on large objects. Transform runs once on the server, so the client pays nothing.
• Payload size. Every useState value and every async-data result is serialised into every SSR response. Measure it in DevTools → Payload, keep runtimeConfig.public tiny, and move large derived or static data into a build-time template instead.
• Internal fetch. From a server route, event.$fetch / $fetch to your own routes goes through Nitro's local dispatcher with no network hop; from a component during SSR, useRequestFetch() forwards cookies and headers.
• Caching, in increasing scope: routeRules (prerender at build, isr, swr with a maxAge, cache), handler-level defineCachedEventHandler with getKey, varies, maxAge, staleMaxAge and shouldBypassCache, and defineCachedFunction for expensive computations. The store behind all of them is unstorage: memory by default, so multi-instance deployments need a shared driver (Redis, KV) to share a cache.
• Never cache a personalised response without varying on the right cookie or header. This is both a correctness bug and a data-disclosure bug, and it is the caching question a senior is expected to raise unprompted.
• Plugins run before render on every SSR request. Keep them light, mark independent ones parallel: true, and make browser-only ones .client.
• Profiling: node --cpu-prof .output/server/index.mjs under autocannon, then open the .cpuprofile in Chrome DevTools; add Server-Timing from a Nitro plugin for per-request visibility.

How it works

Fixing a waterfall without changing what the page renders:

<script setup lang="ts">
// ✗ three round trips, one after another
// const { data: user } = await useAsyncData('user', () => $fetch('/api/user'))
// const { data: orders } = await useAsyncData('orders', () => $fetch('/api/orders'))
// const { data: news } = await useAsyncData('news', () => $fetch('/api/news'))

// ✓ start them together, await once; the slowest one sets the TTFB
const userReq = useAsyncData('user', () => $fetch('/api/user'))
const ordersReq = useAsyncData('orders', () => $fetch('/api/orders'))
const [{ data: user }, { data: orders }] = await Promise.all([userReq, ordersReq])

// ✓ non-critical: do not block navigation at all
const { data: news } = await useAsyncData('news', () => $fetch('/api/news'), { lazy: true })
</script>

Shrinking the payload at the source:

<script setup lang="ts">
const { data: products } = await useAsyncData(
  'products',
  () => $fetch('/api/products'),
  {
    // Runs on the server; only the result crosses the wire.
    transform: list => list.map(p => ({ id: p.id, name: p.name, price: p.price })),
  },
)
</script>

Caching with a bounded, deliberate key:

export default defineCachedEventHandler(
  async (event) => {
    const { region } = getQuery(event)
    return await buildExpensiveReport(String(region ?? 'eu'))
  },
  {
    maxAge: 60,
    staleMaxAge: 300,
    // Only these inputs may enter the key: arbitrary query params would make it unbounded.
    getKey: event => `report:${String(getQuery(event).region ?? 'eu')}`,
    // Anything personalised must vary, or it must not be cached at all.
    varies: ['accept-language'],
    shouldBypassCache: event => !!getCookie(event, 'preview'),
  },
)

Route rules for the whole-page cases:

export default defineNuxtConfig({
  routeRules: {
    '/': { prerender: true },                       // built once at build time
    '/blog/**': { isr: 3600 },                      // rendered on demand, then cached for an hour
    '/pricing': { swr: 600 },                       // served stale while revalidating
    '/account/**': { ssr: true, cache: false },     // personalised: never cached
    '/admin/**': { ssr: false },                    // pure SPA, no server render at all
  },
})

Exercise

Be able to say