Glossary

Short definitions of the terms that come up in the interview, each linking to the page where it matters.

#
__VUE_PROD_HYDRATION_MISMATCH_DETAILS__ Hydration
Vue compile-time flag (set via vite.define) that keeps detailed mismatch warnings in production builds for debugging.
_layersaka nuxt.options._layers Layers
The resolved list of layers on the Nuxt instance, project first, each entry holding cwd, config and meta. Modules read it to scan every layer's directories.
@nuxt/test-utils Modules
Testing toolkit with an e2e API (setup, $fetch, createPage) and a runtime Vitest environment (mountSuspended, mockNuxtImport).
#build Modules
Alias to generated templates in .nuxt; `import x from '#build/my-module/options.mjs'`.
#imports Internals
Virtual module exposing all auto-imports explicitly, so module runtime code works even when the consumer disables the auto-import transform.
#layers aliasaka #layers/<name> Layers
Import alias pointing at a named layer's root, so a project can import a layer file by path regardless of where either lives. Auto-scanned layers are named after their folder.
$meta Layers
Config block naming a layer (`$meta: { name }`). Gives layers listed in extends a stable name and alias.
A
AbortController JavaScript
Object whose `signal` cancels fetches and other async work; `AbortSignal.timeout()` and `AbortSignal.any()` compose deadlines and multiple sources. Cancelling stale requests is the fix for out-of-order search results.
accessible name CSS & a11y
The text assistive technology announces for an element, computed from content, `<label>`, `aria-labelledby` or `aria-label`. Missing names on icon buttons are the most common audit failure.
addBuildPlugin Modules
Kit helper registering an unplugin factory once for Vite, webpack and Rspack.
addComponentsDir Modules
Kit helper registering a directory of components, optionally with a prefix, used per layer by layer-aware modules.
addImports Modules
Kit helper registering auto-imports (composables, utils) for the app registry; addServerImports targets Nitro.
addPlugin Modules
Kit helper registering a runtime plugin; normalises src, infers client/server mode from the filename and prepends to nuxt.options.plugins unless append is true.
addServerHandler Modules
Kit helper registering a Nitro route or middleware from a module's runtime directory.
addTemplate Modules
Kit helper generating a file into .nuxt at build time, virtual by default, importable as #build/<filename>; regenerate with updateTemplates.
addTypeTemplate Modules
Kit helper generating a .d.ts that Nuxt references from its generated tsconfigs, optionally per context (nuxt, nitro, node, shared).
allowBuilds Tooling
pnpm 11+ workspace setting mapping package names to whether their install scripts may run; dependencies' lifecycle scripts are blocked unless listed. Replaced `onlyBuiltDependencies`.
app/ directory Layers
Nuxt 4's home for app code (components, composables, pages, layouts, plugins, app.config) inside a project or a layer; server/, shared/, public/ and modules/ stay at the root.
appConfigaka app.config.ts Layers
Reactive, bundled configuration merged across layers with the project winning; the right channel for theme tokens and UI defaults, not for secrets or per-environment values.
architecture decision record Architecture
A short, numbered, immutable document capturing a significant decision: context and options, the decision, its consequences, and how success will be measured. A new record supersedes rather than edits.
autocannon Memory
HTTP load generator used to warm and stress a server while taking heap snapshots or measuring TTFB.
B
backend-for-frontend Fullstack
A thin server owned by the frontend team that aggregates and shapes upstream APIs for the UI, holds credentials, caches and translates errors. Nitro's `server/api` is a natural BFF.
bfcache Platform
The browser's back/forward cache that restores a whole page instantly on history navigation. Blocked by `unload` handlers, open connections and `Cache-Control: no-store` on the document.
build once, promote Tooling
Pipeline principle: produce one artifact, test it, and move that exact artifact through preview, staging and production, with environment differences supplied by runtime configuration.
C
c12 Internals
unjs config loader behind nuxt.config: loads TypeScript configs, applies $development/$production overrides, resolves extends layers and merges everything with defu.
cachedFunction Fullstack
Nitro utility memoising an async function in the cache storage by key with `maxAge` and optional stale-while-revalidate, coalescing concurrent calls. Production needs shared storage such as Redis or KV.
callOnce Hydration
Runs a function once per navigation or per app, so setup logic does not repeat on the client after SSR already ran it.
cascade layer CSS & a11y
`@layer` groups styles so that layer order, not specificity, decides conflicts between groups. Tailwind 4 and design systems use layers to make overrides predictable.
catalog (pnpm) Tooling
A `pnpm-workspace.yaml` section defining one version per dependency for the whole workspace, referenced as `"catalog:"` in each package, so every app and layer shares one Nuxt and one Vue.
changelogen Modules
Conventional-commit changelog and release tool used by the module starter's release script.
changesets Tooling
Tooling that records the intended version bump and changelog entry per change in a monorepo, then versions and publishes packages together in CI.
ClientOnly Hydration
Component rendering its children only on the client with an optional #fallback slot; the escape hatch, not the default.
closure JavaScript
A function together with the variables of the scope it was created in. The mechanism behind memoisation, debounce timers, module privacy and, when it captures large objects, memory leaks.
compatibilityVersionaka future.compatibilityVersion Landscape
Opt-in switch for the next major's behaviour; `5` enables Nuxt 5 semantics on a 4.x project for testing.
configKey Modules
The nuxt.config property where consumers place a module's options, declared in the module's meta.
consola Modules
Logger behind useLogger(); gives modules scoped, level-aware output.
container query CSS & a11y
`@container` rules that respond to an ancestor's size (or style) rather than the viewport, letting a component adapt wherever it is placed.
Content Security Policy Security
Response header allow-listing where scripts, styles, images and connections may load from. With nonces or hashes and `strict-dynamic` it neutralises most XSS even when an injection slips through.
Core Web Vitalsaka LCPaka INPaka CLS Perf
Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift, the client metrics measured with Lighthouse or web-vitals.
CORS preflight Platform
The `OPTIONS` request browsers send before a cross-origin request that is not "simple" (custom headers, JSON content type, non-GET/POST methods). Cached with `Access-Control-Max-Age`.
createResolver Modules
Kit helper returning resolve() anchored to import.meta.url, the correct way to reference a module's own runtime files.
critical rendering path Platform
The sequence from HTML bytes to first pixels: parse, CSSOM, render tree, layout, paint. Render-blocking CSS and synchronous scripts sit on it; preloading and deferring move work off it.
cross-request state pollution Memory
Request-scoped data stored at process lifetime and read by the next request, the security cousin of a memory leak; fixed with useState, event.context or per-app instances.
CSRF Security
Cross-site request forgery: a third-party page triggers an authenticated request with the victim's cookies. Mitigated by `SameSite` cookies, origin checks, tokens and non-simple content types.
D
D1 Fullstack
Cloudflare's serverless SQLite database, accessed through a Worker binding (`prepare().bind().all()`) with `batch()` instead of transactions. Used by this app for progress sync and by Nuxt Content on Workers.
data-allow-mismatch Hydration
Vue 3.5 attribute whitelisting an expected mismatch on an element (text, children, class, style, attribute).
dedupe Internals
useAsyncData option deciding what happens when a request with the same key is already in flight: cancel (default) or defer.
defineCachedEventHandler Perf
Nitro wrapper caching a handler's response with maxAge, staleMaxAge, swr, getKey, varies and shouldBypassCache; storage defaults to memory.
defineModel Vue docs
Vue 3.4+ macro that declares a two-way bound prop (`modelValue` by default or a named one) and returns a writable ref with a local fallback, replacing the props-plus-emit boilerplate of `v-model` on components.
defineNuxtModule Modules
Kit factory for a module: meta (name, configKey, compatibility), defaults, moduleDependencies, hooks and the setup(options, nuxt) function that runs at build time.
defu Internals
unjs deep-defaults merger. Objects deep-merge, arrays concatenate, the left-hand (higher-priority) scalar wins and undefined never overrides a default.
design tokens Architecture
Named design values (colour, spacing, type, radius, motion) exposed as CSS custom properties or config, mapped per brand and theme so components never hard-code visual decisions.
destr Modules
Safe JSON parsing used to coerce runtime-config environment variables to the type of their default (so "false" becomes false).
devalue Internals
Serialiser for the payload supporting Date, Map, Set, RegExp and BigInt; custom classes need definePayloadReducer/Reviver.
discriminated union TypeScript
A union of object types sharing a literal `kind`/`type` field so TypeScript narrows on it. The idiomatic way to model states (`idle | loading | success | error`) instead of optional flags.
E
effectScopeaka onScopeDispose Memory
Vue API grouping effects so they can be stopped together; onScopeDispose registers cleanup for composables.
ETag Platform
Response validator that lets a client ask "has this changed?" with `If-None-Match` and get a 304 instead of the body. Also used for optimistic concurrency with `If-Match` on writes.
event.context Memory
Per-request storage on the h3 event, typed by augmenting H3EventContext; where request-scoped server state belongs instead of module scope.
expand-then-contract Fullstack
Migration pattern for zero-downtime schema changes: add the new shape first, deploy code that handles both, backfill, then remove the old shape once nothing reads it.
explicit resource management JavaScript
ES2026 `using` and `await using` declarations that call `Symbol.dispose` / `Symbol.asyncDispose` when a block exits, giving deterministic cleanup of connections, locks and listeners.
extends Layers
The nuxt.config option listing layers to merge in, from a local path, an npm package or a git source. The first entry has the highest priority among extended layers.
F
fixture Layers
A minimal Nuxt app used in tests; for a layer, a fixture extends the layer and asserts what it ships and that overrides win.
flaky test Testing
A test that passes and fails without code changes, usually from real time, unawaited work, shared state or network. Quarantined with an owner and a deadline rather than retried indefinitely.
focus trap CSS & a11y
Keeping keyboard focus inside a modal region while it is open and restoring it to the opener on close. The native `<dialog>` with `showModal()` provides it; custom dialogs must implement it.
G
getLayerDirectories() Layers
Kit helper returning each layer's resolved directories (root, app, server, shared, public, modules, appPages…) in priority order, project first.
giget Layers
unjs downloader used by c12 to fetch remote layers and templates from GitHub, GitLab, Bitbucket and sourcehut, with `GIGET_AUTH` for private repositories.
H
h3 Internals
The HTTP framework under Nitro: defineEventHandler, getQuery, readBody, readValidatedBody, createError, setResponseHeader.
h3 Fullstack
The minimal HTTP framework under Nitro: `defineEventHandler`, `H3Event`, and utilities for headers, bodies, cookies and sessions. Nuxt's `server/` routes are h3 handlers.
heap snapshot Memory
A capture of the JS heap in Chrome DevTools; comparing snapshots before and after load and following retainers is how a leak is found.
hookable Modules
unjs hook system behind nuxt.hook / callHook. Listeners run serially by default; callHookParallel and hookOnce exist; hook() returns an unsubscribe function.
hybrid rendering Nuxt app
Choosing a rendering mode per route in one app: static, server-rendered, cached with stale-while-revalidate or client-only, instead of one mode for the whole site.
hydration mismatch Hydration
The client's first render disagreeing with the server HTML; logged in development, silently patched in production at the cost of layout shift and CPU.
hyperfine Perf
Command-line benchmarking tool used to time builds or dev startup with and without a module or layer.
I
idempotency key Fullstack
A client-generated unique key sent with a mutating request so a retry after a timeout does not create a second order or payment; the server stores the first result per key.
installModule Modules
Kit helper that runs another module's setup immediately with given options, without version checks or dedupe awareness.
J
jiti Internals
Runtime TypeScript loader used to import nuxt.config.ts and modules at build time (and by this app's validate script).
K
keyset pagination Coding
Paging with a cursor made of the last row's sort keys (`WHERE (created_at, id) < (?, ?)`) instead of an offset, so pages stay stable under inserts and cost the same at any depth.
knitwork Modules
Code-generation helpers (genImport, genExport, genObjectFromRawEntries) for producing safe JavaScript in templates.
L
layer Layers
A Nuxt project fragment another project extends. Its directories are scanned like the app's and its config is merged; the project always has the highest priority.
lazy hydrationaka hydrate-on-visible Perf
Deferring a component's hydration until visible, idle, interaction or a media query, via Vue 3.5 strategies exposed on Lazy* components.
lazy hydration Nuxt app
Deferring the hydration of a component until it is visible, idle, interacted with or a condition holds (`hydrate-on-visible`, `hydrate-on-idle`, …), so the server HTML stays static and cheap until needed.
Leitner boxes
The spaced-repetition scheme this app uses: a correct answer moves a question up a box (due in 1, 3, 7, 14 days), a miss returns it to box 0.
logical properties CSS & a11y
CSS properties defined by flow direction (`margin-inline-start`, `inset-block`) instead of physical sides, so right-to-left and vertical scripts work without overrides.
LRU cache Coding
Bounded cache evicting the least recently used entry. In JavaScript a `Map` gives O(1) operations because it preserves insertion order: re-insert on access, delete the first key when full.
M
magic-string Internals
Library for editing source text while producing source maps, the standard tool inside a transform plugin.
MaxListenersExceededWarning Memory
Node warning when an emitter exceeds ten listeners, the early smell of listeners registered per request on a process-lifetime emitter.
micro-frontends Architecture
Independently deployed UI fragments composed at runtime (module federation, web components, edge composition). Justified by independent team cadence; costs duplicated runtimes, drift and cross-fragment auth.
microtask JavaScript
A job queued to run after the current script finishes but before the next macrotask or render: promise callbacks, `queueMicrotask`, `MutationObserver`. Vue batches state updates into one flush this way.
minimumReleaseAge Security
pnpm setting that refuses to resolve versions published less than N minutes ago (default one day since pnpm 11), leaving time for malicious releases to be caught and unpublished.
mlly Internals
ESM utilities (resolvePath, findExports, importModule) used by kit's resolver helpers.
module-builderaka @nuxt/module-builder Modules
Builds a module to dist/ (module.mjs, module.json, types) and transpiles src/runtime file by file so resolver paths keep working after publishing.
moduleDependencies Modules
Declarative dependencies between modules (Nuxt ≥ 4.1) with version constraints, defaults, overrides and optional flags; the replacement for imperative installModule calls.
mountSuspended Modules
Test helper mounting a component inside the Nuxt runtime environment so auto-imports and plugins resolve.
mountSuspended Testing
`@nuxt/test-utils` helper that mounts a component inside a Nuxt runtime in Vitest, so auto-imports, plugins and composables such as `useFetch` work in component tests.
N
Nitro Internals
The server engine bundling server/ handlers and the SSR renderer into a deployable output for a preset. Nuxt 4 uses Nitro 2 with h3 v1; Nuxt 5 targets Nitro v3.
Nitro preset Fullstack
The deployment target Nitro builds for (`node-server`, `cloudflare_module`, `vercel`, `static`, …), auto-detected or set via `nitro.preset`/`NITRO_PRESET`. One build per preset, configuration via `runtimeConfig`.
nuxt analyze Perf
CLI command producing client and server bundle treemaps to find heavy chunks and non-tree-shaken code.
nuxt-nightly Landscape
Nightly channel of Nuxt (`nuxt@npm:nuxt-nightly@5x`) used in CI matrices to catch upstream breakage early.
nypm Modules
Package-manager detection and install helper used by `nuxt module add`.
O
ofetch Internals
Fetch wrapper behind $fetch with automatic JSON handling, retries and interceptors.
optimistic update State
Applying a mutation's expected result to the UI before the server confirms it, then reconciling or rolling back on the response. Fast when it usually succeeds; needs an explicit failure path.
Oxlint Tooling
Rust linter from the Oxc project running hundreds of ESLint-compatible rules far faster than ESLint; typically run first, with ESLint kept for stylistic, Vue-template and type-aware rules.
P
pathe Internals
POSIX-style path utilities that behave identically on Windows; prefer it over node:path in module code.
payload Hydration
The serialised state (useState, async data, head) embedded in the SSR response and revived before the client renders; serialised with devalue.
Pinia Colada State
The Pinia team's data-fetching layer (queries, mutations, cache and invalidation) built on Pinia, an alternative to TanStack Query for client-side server-state management.
Pinia setup store State
A store defined with a function that returns refs, computeds and actions, mirroring `<script setup>`. Pinia 4 is ESM-only and the recommended state library for Vue 3 and Nuxt.
playground Layers
The development app inside a layer or module repository (`.playground/` or `playground/`) that extends or installs it for manual testing.
project references TypeScript
TypeScript's way to split one repository into separately checked projects. Nuxt 4 generates references for app, server, shared and node code so each sees only the globals it really has.
prototype pollution Security
Injecting `__proto__` or `constructor.prototype` keys through a deep merge or path setter so every object inherits attacker-chosen properties. Safe merges skip those keys.
R
reactive effect Vue
A function Vue re-runs when reactive state it read changes. Computed properties, watchers and component render functions are all effects; dependencies are tracked per property access during the run.
registerEndpoint Testing
`@nuxt/test-utils` helper that stubs a server route in the Nuxt Vitest environment, letting component tests exercise `useFetch` without a network.
Rolldown Landscape
Rust bundler powering Vite 8, which Nuxt 4.5 runs on.
Rolldown Tooling
The Rust bundler that powers Vite 8, replacing esbuild and Rollup with one engine for dev and production and using Oxc for transforms. `build.rollupOptions` became `build.rolldownOptions`.
rootDir Layers
The project root where nuxt.config, .env, package.json and the layers/ directory live.
route rulesaka routeRules Perf
Per-route configuration in nuxt.config (prerender, swr, isr, cache, redirect, headers, ssr: false); merged as an object across layers.
routeRules Nuxt docs
Nuxt configuration mapping route patterns to rendering and caching behaviour: `prerender`, `swr`, `isr`, `ssr: false`, headers, redirects, proxies and `appMiddleware`. The rendering decision table made executable.
roving tabindex Coding
Keyboard pattern for composite widgets (tabs, toolbars, grids): only the active item is tabbable (`tabindex="0"`), arrow keys move focus and update which item is active.
Rspack builder Landscape
Alternative Nuxt builder (`builder: '@nuxt/rspack-builder'`) using Rspack 2 with an Rsbuild pipeline.
runtimeConfig Modules
Per-environment values. The private part is server-only; `public` is serialised into every SSR payload; both are overridable at runtime by NUXT_* environment variables.
runtimeConfig Nuxt docs
Configuration read when the server starts, overridable with `NUXT_*` environment variables; `public` keys are also shipped to the client. Contrast with `app.config`, which is baked in at build time.
S
SameSite cookie Platform
Cookie attribute controlling cross-site sending: `Lax` (default, top-level navigations only), `Strict`, or `None` (requires `Secure`). The first line of CSRF defence for session cookies.
satisfies TypeScript
TypeScript operator that checks a value against a type while keeping the value's own, narrower inferred type; ideal for config objects and `as const`-style literals.
scule Modules
String-case helpers (pascalCase, kebabCase, camelCase) used for component and config names.
sealed session cookie Security
Session data encrypted and signed into the cookie itself (h3 `useSession`, nuxt-auth-utils), so the server needs no session store; it must stay small and be `HttpOnly`, `Secure` and `SameSite`.
server componentaka islandaka NuxtIslandaka .server.vue Hydration
Component rendered only on the server (islands) so heavy markup and its dependencies never reach the client bundle.
server component (island) Nuxt app
A `.server.vue` component rendered only on the server and delivered as HTML; it ships no JavaScript and cannot hold client state. `<NuxtIsland>` renders one on demand.
Server-Timing Perf
Response header exposing server-side timings to browser DevTools; a Nitro plugin can add render and data durations.
shallowRef Vue
A ref whose `.value` is tracked but whose contents are not made deeply reactive. The right container for large lists, external instances and anything replaced wholesale rather than mutated.
shared/ Layers
Directory whose utils and types are auto-imported in both the Vue app and Nitro (Nuxt ≥ 3.14); must not import Vue or Nitro code. Scanned per layer.
size-limit Perf
Bundle-size budget tool for CI; use it to fail when a layer or module grows the client bundle past a threshold.
srcDir Layers
The directory Nuxt scans for app code; `app/` in Nuxt 4, resolved separately for every layer.
stale-while-revalidate State
Serve the cached value immediately and refresh it in the background. Nuxt's `swr` route rule, Nitro's cached handlers and client query libraries all implement the pattern.
state placement table Architecture
A design-interview artefact listing every kind of state and where it lives: URL, `useState`, store, query cache, cookie, browser storage, server. Forces decisions about SSR, sharing and persistence.
strangler migration Architecture
Replacing a system incrementally by routing slices of traffic to the new one behind flags or route rules until the old one is empty, keeping rollback trivial. The alternative to a rewrite.
structuredClone JavaScript
Built-in deep copy that handles cycles, `Date`, `Map`, `Set` and typed arrays but rejects functions and DOM nodes and drops prototypes; the default replacement for JSON round-trips.
T
testing trophy Testing
Kent C. Dodds' shape for a test suite: static analysis at the base, a few unit tests, many integration (component) tests, a thin layer of end-to-end tests. The usual balance for a Nuxt app.
transactional outbox Fullstack
Writing a "to do later" row (send email, reindex) in the same transaction as the business change, processed by a worker with retries, so side effects are neither lost nor duplicated.
TTFB Perf
Time to first byte, the server-side metric driven by data waterfalls, plugin cost, cache hits and payload serialisation.
type predicate TypeScript
A function returning `value is T` (or asserting with `asserts value is T`) so the compiler narrows after the call. Runtime validators such as zod produce them for you.
U
ufo Internals
unjs URL utilities (joinURL, withQuery, withTrailingSlash) used throughout Nuxt and worth using in module code instead of string concatenation.
unctx Internals
unjs async-context helper that lets useNuxt() and useNuxtApp() find the current instance without passing it around. Nuxt 4.5 moved to unctx v3.
unhead Internals
Head management library behind useHead, useSeoMeta and useHeadSafe; sorts tags for performance. Nuxt 4.5 runs unhead v3.
unimport Internals
unjs auto-import engine. Builds the registry of composables and utils, rewrites bare identifiers to explicit imports at build time and exposes the virtual #imports module.
unplugin Internals
unjs abstraction for writing one bundler plugin that works in Vite, webpack and Rspack; addBuildPlugin registers one.
unstorage Internals
unjs key-value storage layer with drivers (fs, memory, Redis, KV…) behind Nitro's useStorage and cache.
untyped Internals
unjs schema utility Nuxt uses to resolve every option's defaults and types ($resolve / $default) when building nuxt.options.
useAsyncData key Nuxt docs
The string identifying a data fetch in the Nuxt payload and cache. Two calls with the same key share data, dedupe requests and hydrate from the server; a missing or colliding key is the classic double-fetch bug.
useId Hydration
Vue 3.5 composable generating ids that are stable between server and client, the correct fix for generated id/aria attributes.
useNuxt Modules
Returns the current Nuxt build instance from unctx; only works inside module setup and build hooks, never at runtime.
useState Hydration
SSR-shared reactive state keyed by name, serialised into the payload and revived on the client; the fix for module-scope refs polluting requests.
useState Nuxt docs
Nuxt's SSR-friendly shared state: created once per request on the server, serialised into the payload and hydrated on the client. The replacement for module-scope state, which leaks between users on the server.
useTemplateRef Vue docs
Vue 3.5 composable returning a ref bound to a template `ref="name"` attribute, typed and usable in composables, replacing the convention of a same-named `ref()` in setup.
V
Vapor mode Vue
Vue 3.6's compilation strategy that skips the virtual DOM and updates the DOM directly from fine-grained reactivity. Opt-in per component; Nuxt 4 exposes it experimentally through `vue.vapor` interop.
Vite Environment API Landscape
Vite 6+ model of one shared config with environment-specific plugins; Nuxt 5 uses it instead of separate client and server configs.
W
WCAG 2.2 AA CSS & a11y
The accessibility conformance level most contracts and the European Accessibility Act point at: contrast, keyboard operability, focus visibility, target size, consistent help, no keyboard traps, among others.
worker pool (promises) Coding
A concurrency limiter: N async workers pull tasks from a shared index until none remain, preserving result order by index. The hand-written form of `p-limit`/`p-map`.
X
XSS Security
Cross-site scripting: attacker-controlled text executed as script in a victim's browser. In Vue it comes from `v-html`, `href="javascript:"`, unsafe URL construction and server-side string templating, not from `{{ }}`.