Interview keywords

Single entry to backend services that centralizes cross-cutting concerns like TLS, auth, caching, and rate limiting.

Next.js routing system using the app directory with layouts and server components.

When separate codebases diverge in patterns, deps, and quality until switching teams feels like learning a new stack.

Accessible Rich Internet Applications — attributes that describe roles and states for assistive tech.

CSS approach of tiny single-purpose utility classes; Tailwind is a popular implementation of this style.

A backend owned by the client team that shapes APIs for that UI, aggregating microservices without waiting on every backend team.

How much of a system a bug or bad deploy can break; smaller services/apps limit damage and speed up verification.

How content, padding, border, and margin combine to determine an element's size.

Tool that combines modules into optimized bundles for the browser.

Changing asset URLs (often via content hashes) so browsers/CDNs fetch the new build instead of a stale cached file.

Serving an asset from a CDN/cache instead of the origin—faster responses when the object is already nearby.

Removing or updating cached assets when a new version ships so users don’t keep seeing stale files.

Content Delivery Network — geographically distributed servers that cache static assets.

Continuous Integration and Delivery — automated testing and deployment pipelines.

Browser downloads a shell then runs JS to fetch data and render UI—can mean a white screen and weaker SEO.

A function that retains access to variables from its enclosing scope after that scope has closed.

Breaking JS into smaller chunks (often by route) so pages download only what they need instead of one huge bundle.

The older Node module system using require() and module.exports. Still everywhere in the ecosystem; .cjs forces this format.

Platforms like Kubernetes/ECS that run containers at scale—scheduling, restarts, and often load balancing for you.

Systems tend to mirror the org chart—small independent teams usually need independently shippable architecture slices.

Google metrics for loading (LCP), interactivity (INP), and visual stability (CLS).

Cross-Origin Resource Sharing — browser rules for requests across different domains.

Steps from HTML/CSS download to pixels: DOM, CSSOM, render tree, layout, paint, and composite.

Two-dimensional layout system for rows and columns with explicit track sizing.

Rules that decide which selector wins when multiple styles target the same element.

Core Web Vital for visual stability: how much the page layout unexpectedly jumps while loading.

Data structure that speeds up lookups at the cost of extra storage and write overhead.

Group of operations that succeed or fail together to keep data consistent.

Technique that delays a function until after a pause in events, common for search inputs.

Shared tokens and reusable UI components that keep micro-frontends visually coherent and cut duplicated UI code.

Named design decisions (colors, spacing, type) often as CSS variables so products share one visual language.

Lightweight isolated environment bundling an app and its dependencies.

Packaged app plus runtime/OS layers built from a Dockerfile so anything running Docker can deploy the same artifact.

Loading resources up front on first visit—simple but can hurt Core Web Vitals if you ship too much JS/CSS.

Dense vector representation of text used for similarity search and retrieval.

JavaScript’s official module system using import and export. In Node, .mjs files are ESM; "type": "module" in package.json makes .js ESM too.

Mechanism that coordinates the call stack, task queue, and microtasks in JavaScript runtimes.

Further training a pre-trained model on domain-specific data for specialized behavior.

CSS layout model for distributing space and aligning items along a single axis.

A single frontend codebase and deployable where most UI lives together—simple early on, hard to scale with large teams.

TypeScript feature for writing reusable code that works across multiple types safely.

Query language where clients request exactly the fields they need from a single endpoint.

When an LLM confidently generates incorrect or fabricated information.

Behavior where declarations are moved to the top of their scope before execution.

Attaching client-side JavaScript to server-rendered HTML to make it interactive.

Updating static pages after build without rebuilding the entire site.

Core Web Vital for interactivity: how long until the UI updates after a user interaction.

Users spend most of their time on other sites, so they prefer yours to work the same way—familiar patterns beat novel UI.

JavaScript Object Notation — a text format for structured data (objects/arrays). Ubiquitous in APIs and config files.

A syntax extension that lets you write HTML-like markup inside JavaScript. Tools transform it into function calls (e.g. React.createElement).

JSON Web Token — compact signed payload often used for stateless authentication.

Framework for composing LLM apps with chains, agents, and tool integrations.

Neural network trained on vast text to generate and understand natural language.

Core Web Vital for loading: time until the largest visible content element is painted after navigation.

Loading code or assets when needed (route visit, scroll, click) instead of eagerly on first paint.

Automated audit tool measuring performance, accessibility, SEO, and best practices.

Distributes traffic across identical server instances so one machine isn’t the bottleneck under high concurrency.

A generated dependency pin file (package-lock.json, pnpm-lock.yaml, yarn.lock) so installs reproduce the same versions everywhere.

Pattern where an LLM response can instruct the app to render rich UI (cards, maps), not only plain text in chat.

Host app that owns cross-cutting concerns (auth, routing, locale, global state) and loads child micro-frontends.

Splitting a frontend into independently deployable apps composed together, often owned by separate teams.

Backend style of small independently deployable services communicating via APIs—often paired with micro-frontends.

Functions that run between a request and route handler, often for auth or logging.

Standard for connecting AI coding agents to tools and data sources (e.g. Figma) so agents can use real project context.

One repository holding many apps/packages with shared tooling—reduces drift and helps agents change across boundaries.

Object-Relational Mapping — library that maps database rows to application objects.

Downloading more data than the UI needs—common when one generic API serves clients with different screen/data needs.

The Node/npm project manifest: name, scripts, dependencies, and settings like "type": "module" that affect how .js files load.

Repeatedly calling an endpoint until state changes—simple real-time pattern that can waste requests and race.

Object representing the eventual completion or failure of an asynchronous operation.

Crafting inputs and instructions to steer LLM outputs toward reliable results.

Retrieval-Augmented Generation — fetching relevant docs before prompting an LLM.

Throttling how many requests a client can make—usually enforced at an API gateway for security and stability.

API for passing data through the component tree without prop drilling at every level.

Functions like useState and useEffect that let function components use state and lifecycle.

Components that render on the server and send serialized output to the client.

Higher-order component that skips re-rendering when props are shallowly equal.

React's process of comparing element trees and applying minimal DOM updates.

Architectural style using HTTP verbs and resource URLs for client-server communication.

HTML elements chosen for meaning (header, nav, main) rather than only for styling.

One-way server→client event stream over HTTP; common for LLM token streaming (not WebSockets or polling).

Rendering pages on the server per request and sending HTML to the browser.

Authentication scheme where one login grants access to multiple applications.

App that loads once and navigates client-side without full page reloads; often paired with CSR.

Pre-rendering pages at build time into static HTML assets.

Technique that limits how often a function runs during rapid events like scroll or resize.

Subword unit LLMs process; pricing and context limits are measured in tokens.

Neural architecture using self-attention, foundation of most modern LLMs.

Build step that removes unused exports to reduce bundle size.

TypeScript’s project config — compiler options, which files to include, path aliases, and JSX settings.

JSX written in TypeScript files (.tsx) — UI markup with static types for props and components.

Runtime check that narrows a union type within a conditional block.

Compiler ability to deduce types without explicit annotations.

Needing many round trips because endpoints return too little data for a screen—common with chatty REST APIs.

Type that allows a value to be one of several specified types.

Database optimized for storing and querying high-dimensional embedding vectors.

A feature owned end-to-end by one team—UI plus the services/APIs in that domain—so the team can ship independently.

In-memory representation of UI that React diffs against to minimize real DOM updates.

Persistent bidirectional channel between browser and server—great for chat, heavier than one-way streams.

A JavaScript file that uses CommonJS modules (require/module.exports). Used when you need CommonJS inside an ESM-oriented project.

A Cascading Style Sheets file that describes how HTML looks: colors, layout, typography, and responsive rules.

A TypeScript declaration file — types only, no runtime code. Describes the shape of JS libraries so the type checker understands them.

An environment variables file (KEY=value) for secrets and config. Not committed when it holds secrets; tools load it into process.env.

A local-only env file (common in Next.js) for machine-specific secrets. Usually gitignored so keys never hit the repo.

An image format known for simple animations. Still seen on the web, though video or animated WebP/AVIF is often preferred now.

A Git config file listing paths Git should not track — e.g. node_modules, .env.local, and build output.

Short extension for GraphQL documents — queries, mutations, or schema snippets in plain text.

A GraphQL document file — operations (queries/mutations) or schema definitions stored as plain text. Sometimes uses the shorter .gql extension.

An HTML document file — the markup a browser loads as a page’s structure (headings, links, forms, etc.).

Same format as .jpg — a compressed photo image type. The two extensions are interchangeable in practice.

A compressed photo image format (also written .jpeg). Great for photographs; does not support transparency like PNG or many WebP images.

A JavaScript source file. Historically the default extension for JS; today it may be treated as CommonJS or ES modules depending on package.json and the runtime.

A JSON data file: plain text objects/arrays used for configs, APIs, and package metadata. Not executable code.

JSON with Comments — like JSON but allows // and /* */ comments. Often used for editor/tooling configs (e.g. some tsconfig setups).

A JavaScript file that can include JSX — HTML-like syntax for describing UI, most often used with React components.

A source map file that maps minified/bundled code back to original source lines — used by browser DevTools when debugging production builds.

A Markdown file — lightweight plain text with simple formatting for READMEs, docs, and notes. Renders to HTML in many tools.

Markdown that can embed JSX components. Common for documentation sites and content-driven Next.js pages.

A JavaScript file that uses ECMAScript Modules (import/export). Common in Node.js to mark a file as ESM instead of CommonJS.

A raster image format that supports transparency. Common for UI assets and screenshots; larger than optimized WebP/AVIF for photos.

A Sass stylesheet file using SCSS syntax (nesting, variables, mixins). Compiled to regular .css before the browser uses it.

A shell script file (usually Bash) that runs command-line steps — installs, builds, deploys, or automation.

A SQL script file with database statements — queries, migrations, or seed data for systems like Postgres.

Scalable Vector Graphics — an XML-based image format that stays sharp at any size; often used for icons and illustrations.

A TOML config file — clear key/value sections used by tools like Cargo, some Python packagers, and assorted CLIs.

A TypeScript source file: JavaScript plus static types. Compiles (or is bundled) down to JavaScript before browsers run it.

A TypeScript file that can include JSX. The usual extension for typed React components.

A WebAssembly binary module — compiled code (often from Rust/C/C++) that runs near-native speed in the browser alongside JavaScript.

A modern image format with strong compression for photos and graphics on the web, often smaller than JPEG/PNG at similar quality.

A compressed web font file format. The usual choice for shipping custom fonts efficiently to browsers.

A YAML config/data file — indentation-based text used by CI, Docker Compose, and many cloud/tools configs. Also seen as .yml.

Short extension for YAML config files — same format as .yaml, common in CI and DevOps tooling.