Web Development Glossary
Key terms from the Web Development course, linked to the lesson that introduces each one.
590 terms.
A
- Above-the-fold images
- The hero image or logo should load immediately (use loading="eager" or omit the attribute)
- Lesson 1250 — The loading='lazy' Attribute
- Absolute
- Absolute is like placing a sticker on a piece of paper.
- Lesson 221 — Fixed vs Absolute Positioning
- Access-Control-Request-Method
- The HTTP method you plan to use (PUT, DELETE, etc.)
- Lesson 862 — The OPTIONS Preflight Request
- Accessibility Tree
- A hierarchical view showing how this element fits into the tree structure, including its parent and children nodes
- Lesson 2184 — Accessibility Tree Inspection
- action
- The URL (destination) where the form data will be sent—like the address on an envelope
- Lesson 91 — The <form> Element and Form Submission
- additions
- Announce when new elements are added to the live region
- Lesson 1027 — aria-atomic and aria-relevantLesson 1114 — aria-relevant for Filtering Changes
- Age Gates
- Age Gates are the first line of defense.
- Lesson 2961 — Children's Privacy and Age Verification
- Alt+S
- For example, Alt+S is safer than just S because the latter would interfere with typing.
- Lesson 1096 — Keyboard Shortcut Handlers
- Analogy
- Imagine debugging a car accident. A photo of the crashed car (the error) is useful, but dashcam footage showing the 30 seconds before impact (breadcrumbs) reveals the cause.
- Lesson 673 — DOM Performance ConsiderationsLesson 1818 — Pre-rendering and Edge DistributionLesson 2102 — Overscan and Buffer ItemsLesson 2812 — Error Context and Breadcrumbs
- Analyze bundles
- understand what code is where in your build reports
- Lesson 1420 — Chunk Naming and Output
- Ancestor filtering
- Toggle "Ancestors" to see if parent elements are interfering with event flow
- Lesson 2185 — Event Listeners Panel
- any part of the page's content
- First Contentful Paint (FCP) is a performance metric that measures the time from when the page starts loading to when any part of the page's content is rendered on the screen.
- Lesson 1731 — First Contentful Paint (FCP)
- App Shell Components
- App Shell Components are your top priority.
- Lesson 2418 — Precaching Static Assets
- Application panel
- The Application panel is your control center for everything related to a website's client-side storage, Progressive Web App (PWA) capabilities, and background processes.
- Lesson 2233 — Application Panel Overview and Navigation
- application runtime
- The browser is also called an application runtime because it doesn't just display static content—it runs code (client-side JavaScript) right on your device, making pages interactive without constantly asking the server for help.
- Lesson 16 — What is a Web Browser?
- Applied after HTML parsing starts
- the HTTP header is processed earlier, providing better protection
- Lesson 2876 — CSP Meta Tag Alternative
- aria-disabled attribute
- The aria-disabled attribute is purely informational.
- Lesson 1025 — aria-disabled vs disabled Attribute
- ArrayBuffer
- An ArrayBuffer represents raw binary data in JavaScript—think of it as a fixed-length container of bytes with no inherent structure.
- Lesson 2691 — Reading Files as ArrayBuffer
- art direction
- This is called art direction, and <picture> is your tool.
- Lesson 421 — Art Direction with the Picture Element
- Ascent
- Ascent is the distance from the baseline (where letters sit) to the top of the tallest characters.
- Lesson 1302 — Measuring Font Metrics: Ascent, Descent, and Line Gap
- aspect ratio
- An aspect ratio is the relationship between width and height (like 16:9 for widescreen or 1:1 for squares).
- Lesson 290 — Aspect Ratios and Flex ItemsLesson 396 — Aspect Ratio Media Features
- Asymmetric Designs
- Decorative elements like diagonal cuts, ribbon corners, or wave patterns don't auto-flip. You'll need separate assets or CSS transforms depending on whether the asymmetry is decorative (might stay) or directional (should flip).
- Lesson 2526 — RTL-Specific Edge Cases
- atomic deployment
- An atomic deployment means your entire site switches from the old version to the new version in one instantaneous operation—like flipping a light switch.
- Lesson 1820 — Atomic Deployments
- Attribute selectors
- Attribute selectors are slower than classes:
- Lesson 137 — Selector Performance Considerations
- Audit Trail
- Refresh token usage can be logged server-side, tracking when and where new access tokens are issued.
- Lesson 1605 — Why Refresh Tokens Exist
- Authentication
- Authentication is showing your ID at check-in to prove you're the person who made the reservation
- Lesson 1566 — Authentication vs Authorization: Core DistinctionLesson 1627 — Understanding Authorization vs Authentication
- Authorization
- Authorization is your room keycard that grants access only to your room (not other guests' rooms or staff areas)
- Lesson 1566 — Authentication vs Authorization: Core DistinctionLesson 1627 — Understanding Authorization vs Authentication
- auto
- The browser decides. Different browsers handle this differently, so it's unpredictable.
- Lesson 567 — The font-display Property
- Avoids duplication
- The visible text serves as the accessible name
- Lesson 1020 — aria-labelledby: Referencing Existing Labels
B
- backend
- Client-server separation means your frontend (the client) and backend (the server) are completely separate concerns that communicate only through a defined interface—the REST API.
- Lesson 1474 — Client-Server Separation
- badge
- A small monochrome icon for the device's notification tray (typically 72x72)
- Lesson 2351 — Displaying Notifications with showNotification()
- Bandwidth Consumption
- Oversized images waste users' data plans and server bandwidth. Serving a 3000×2000px image when only 600×400px is displayed is like shipping an entire warehouse when someone ordered a box.
- Lesson 1995 — Why Image Optimization Matters for Performance
- base
- The public base path for deployment (important for nested URLs)
- Lesson 1372 — The vite.config.js File
- Base styles for mobile
- Base styles for mobile means writing your default CSS as if you're designing for a smartphone—no media queries yet.
- Lesson 381 — Base Styles for Mobile
- baseline
- In typography, the baseline is the invisible line that letters "sit" on—the bottom of most lowercase letters (excluding descenders like in g or p).
- Lesson 277 — align-items: baseline Alignment for Typography
- Battle-Tested Strategies
- The caching patterns you've learned (cache-first, network-first, stale-while-revalidate) come pre-built, optimized, and debugged by Google's team.
- Lesson 2404 — What is Workbox and Why Use It
- Better memory efficiency
- The browser doesn't choke on massive arrays
- Lesson 1507 — Why Pagination Matters
- bidirectional control characters
- Unicode provides invisible "traffic signals" called bidirectional control characters that explicitly mark text direction:
- Lesson 2522 — Bidirectional Text (Bidi) Challenges
- Block
- In BEM (Block, Element, Modifier), a block is a standalone, reusable component that can exist on its own anywhere on your page.
- Lesson 596 — BEM (Block Element Modifier) MethodologyLesson 1320 — BEM Fundamentals: Block, Element, ModifierLesson 1321 — BEM Block Naming
- Blog posts and documentation sites
- Blog posts and documentation sites are ideal candidates.
- Lesson 1766 — When SSG is the Best Alternative
- body
- The main message text beneath the title
- Lesson 2351 — Displaying Notifications with showNotification()
- border-box
- The entire package is guaranteed to be 12 inches. The pizza inside adjusts to make room for the box thickness and extras.
- Lesson 140 — Content Box vs Border Box
- breakpoint
- A breakpoint is a debugging tool that pauses your JavaScript execution at a specific line of code.
- Lesson 2253 — What Are Breakpoints and Why Use Them
- Browser Process
- The manager—handles the address bar, bookmarks, and coordinates everything
- Lesson 17 — Browser Architecture Overview
- Build Command
- The terminal command that compiles your site. For Next.js, it's typically npm run build. For Eleventy, it might be npx @11ty/eleventy. This command transforms your source files, fetches build-time data, and generates static HTML, CSS, and JavaScript.
- Lesson 1813 — Build Configuration
- Built-In Cache Management
- Features like cache expiration, size limits, and versioned caching are handled automatically with simple configuration options.
- Lesson 2404 — What is Workbox and Why Use It
- bundlesize
- bundlesize is a lightweight npm package that checks JavaScript and CSS file sizes against defined limits in your package.json.
- Lesson 1937 — Enforcing Budgets in CI/CD
- Buttons
- Buttons are standalone controls and can handle bolder indicators:
- Lesson 1060 — Focus Styles for Different Element Types
C
- Cache API
- The Cache API is fundamentally different from localStorage and IndexedDB because it's designed to store HTTP request-response pairs — entire network resources like HTML files, CSS, images, and API responses.
- Lesson 809 — What is the Cache API and Why It MattersLesson 816 — Cache API vs localStorage and IndexedDB
- Cache Hit Rate
- The percentage of requests served from cache. A high hit rate (70-90%) usually indicates effective caching for that resource type.
- Lesson 2403 — Analytics and Cache Performance Monitoring
- Cache Ignorance
- The server doesn't know what's already in the browser cache, potentially pushing resources the client already has
- Lesson 2121 — HTTP/2 Server Push
- call stack
- The call stack is a record of function calls your program has made to reach the current point of execution.
- Lesson 2270 — The Call Stack and Stack Frames
- canonical URL
- A canonical URL is the preferred, "official" version of a page that you declare when duplicate or very similar content exists at multiple URLs.
- Lesson 1846 — What is a Canonical URL?
- Capsize
- Fontaine and Capsize are automation tools that handle all this complexity for you.
- Lesson 1307 — Automatic Fallback Generation ToolsLesson 1316 — Tools for Calculating Fallback Metrics
- categories
- An array of standardized tags that classify your app's purpose
- Lesson 2304 — Categories and Description
- CDN benefits
- Global distribution often means faster delivery
- Lesson 561 — Self-Hosting vs. Font Services
- child-src
- child-src is broader, covering iframes plus web workers.
- Lesson 2848 — The frame-src and child-src Directives
- Chunked uploading
- Chunked uploading means dividing a large File object into sequential slices using the Blob.slice() method, uploading each chunk separately, then reassembling them on the server.
- Lesson 2717 — Chunked Upload for Large Files
- Clean edges
- The container's padding remains undisturbed
- Lesson 279 — gap: Modern Spacing Between Flex Items
- Clear explanation
- Tell users exactly what happened: "We couldn't find that page" is better than cryptic codes.
- Lesson 1681 — Not Found and Resource Errors
- Clear site data button
- The nuclear option that wipes everything checked
- Lesson 2242 — Clear Storage and Testing Fresh States
- Client-side
- Client-side refers to anything that happens in your web browser on your device.
- Lesson 12 — Client-Side vs Server-Side
- Client-side evaluation
- Client-side evaluation means your JavaScript code in the browser fetches flag configurations and decides which features to show.
- Lesson 2820 — Client-Side vs Server-Side Feature Flags
- Client-side routing
- Client-side routing is when your JavaScript code handles URL changes and decides what content to display—without asking the server for a new HTML page.
- Lesson 975 — Client-Side Routing Fundamentals
- Clock dependency
- If the server clock is wrong, or the client's clock differs from the server's, caching breaks
- Lesson 2143 — Expires Header
- closed
- The shadow root is not accessible externally. Calling element.shadowRoot returns null. This provides stricter encapsulation but makes debugging harder.
- Lesson 2461 — Creating a Shadow Root
- Code snippets
- the class names or CSS needed to apply each style
- Lesson 594 — Documentation and Type Specimens
- color gamut
- The color gamut is the range of colors that palette contains.
- Lesson 491 — Understanding Color Spaces: sRGB, Display-P3, and Beyond
- color space
- A color space is like a defined palette that determines which colors can be represented and how they're measured.
- Lesson 188 — Color Space Basics
- columns
- Think of a virtual grid as nested virtualization: you calculate which rows are visible (just like vertical scrolling), then for each visible row, calculate which columns are visible horizontally.
- Lesson 2103 — Virtual Grid Layouts
- combobox
- A combobox is a hybrid UI component that merges a text input field with a listbox popup.
- Lesson 1198 — Combobox Pattern Fundamentals
- Component portability
- Component portability means everything needed travels together
- Lesson 602 — CSS-in-JS Philosophies
- component-based CSS
- Think of building a house: component-based CSS is like ordering pre-fabricated room modules (a complete kitchen, bathroom, etc.), while utility-first CSS is like having a toolbox of individual materials (bricks, pipes, tiles) you assemble yourself.
- Lesson 654 — Utility-First vs Component-Based CSS: Understanding the Trade-offs
- Component-based responsive design
- Component-based responsive design means building components that respond to their own container using container queries, not the viewport.
- Lesson 439 — Component-Based Responsive Design
- Component-level access control
- Component-level access control means creating wrapper components that check permissions and only render their children if the user has the required role.
- Lesson 1632 — Component-Level Access Control
- Components layer
- In ITCSS, the Components layer is where you build the recognizable, reusable pieces of your user interface.
- Lesson 1337 — The Components Layer: UI Patterns and Widgets
- Computed fields
- Computed fields are values calculated during the build process by analyzing your content data—they're not stored in your CMS, but generated on the fly from existing information.
- Lesson 1787 — Related Content and Computed Fields
- Computed Properties
- The final accessibility role, name, description, and value the browser exposes
- Lesson 2184 — Accessibility Tree Inspection
- Conditional loading
- Conditional loading means your analytics code only initializes after the user grants permission—no tracking happens until they say "yes."
- Lesson 2788 — Consent Management for Analytics
- Conditional rendering during hydration
- Conditional rendering during hydration means deliberately showing nothing or a placeholder on the server, then revealing browser-specific content only after hydration completes.
- Lesson 1748 — Conditional Rendering During Hydration
- Consent
- Consent means the user actively agrees to data processing through an affirmative action (like checking a box or clicking "Accept").
- Lesson 2960 — Legitimate Interest vs Consent
- Consent Management Platform
- A Consent Management Platform is a third-party service that handles the entire lifecycle of user consent—displaying banners, capturing preferences, storing choices, and blocking scripts accordingly.
- Lesson 2973 — Consent Management Platforms (CMPs)
- Constraint validation
- Constraint validation is the browser's built-in system that automatically checks whether form inputs meet specific requirements before the form is submitted.
- Lesson 896 — What is Constraint Validation?
- container
- The container is the single GTM snippet you install once on every page.
- Lesson 2802 — Google Tag Manager Architecture
- Content
- Tells Tailwind which files to scan for class names (your HTML, JavaScript, etc.). This is critical for Tailwind to know what CSS to generate.
- Lesson 265 — Flexbox and the Box ModelLesson 607 — Tailwind Configuration File
- Content negotiation
- Content negotiation means the server inspects the Accept-Language header and returns content in the detected language without changing the URL.
- Lesson 2540 — Content Negotiation vs Explicit URLs
- Content updates
- A news article or product page has changed on the server
- Lesson 813 — Deleting Cached Entries
- Content-box
- The 12 inches measures only the pizza itself. The box, napkins, and packaging add extra size—your delivery is bigger than 12 inches.
- Lesson 140 — Content Box vs Border Box
- Content-heavy sites
- Content-heavy sites are Jamstack's sweet spot.
- Lesson 1822 — When Jamstack Fits Best
- cookie policy page
- A cookie policy page is a dedicated document on your website that provides complete transparency about every cookie your site sets.
- Lesson 2972 — Cookie Policy Pages and Transparency
- Cookies
- Ironically, you typically store consent preferences in a cookie (often named something like cookie_consent). This is usually considered an "essential" cookie that doesn't require consent itself.
- Lesson 825 — Cross-Tab and Offline ScenariosLesson 2970 — Storing and Respecting Consent Choices
- Crawl budget
- Crawl budget is the number of pages Googlebot will crawl on your site within a given timeframe.
- Lesson 1878 — Googlebot's JavaScript Rendering
- Critical
- Even if your font is on the same domain, you must include this attribute. Fonts are fetched using anonymous CORS mode, and omitting crossorigin will cause the font to be downloaded twice—once by the preload and again when CSS requests it.
- Lesson 1294 — The <link rel="preload"> Syntax for Fonts
- critical difference
- The critical difference is how long they keep your data around.
- Lesson 771 — localStorage vs sessionStorage
- critical rendering path
- The critical rendering path is the sequence of steps the browser must complete before it can display content to the user.
- Lesson 2167 — Critical Path Analysis
- CSS Modules
- CSS Modules is a build-time solution that automatically transforms your class names into unique identifiers.
- Lesson 601 — CSS Modules and Scoped StylesLesson 1341 — What Are CSS Modules
- CSS pixels
- CSS pixels are abstract reference units that browsers use for consistent sizing.
- Lesson 379 — Device Pixels vs CSS Pixels
- CSS variables
- CSS Custom Properties, commonly called CSS variables, are entities you define in your CSS that hold specific values you can reuse throughout your stylesheet.
- Lesson 467 — What are CSS Custom Properties?
- Custom dimensions
- Custom dimensions are event-scoped attributes that describe what happened in a specific interaction:
- Lesson 2786 — Custom Dimension and User Properties
- Custom interactions
- A grid of cells that users can navigate with arrow keys needs role="grid" and role="gridcell"
- Lesson 1036 — ARIA for Application-Like Interfaces
- Custom properties
- Custom properties are real CSS that browsers understand natively and can be manipulated at runtime
- Lesson 467 — What are CSS Custom Properties?
D
- data layer
- The data layer is a JavaScript array (typically named dataLayer) that acts as a communication bridge between your website and Google Tag Manager.
- Lesson 2790 — Analytics Data Layer PatternsLesson 2806 — Data Layer Implementation
- dataTransfer
- A special object that carries data being dragged (text, files, URLs) between source and destination
- Lesson 757 — Event Object Properties for Different Event Types
- default value
- The default value is additions text, which covers most common scenarios.
- Lesson 1114 — aria-relevant for Filtering Changes
- DELETE
- Deleting something that's already gone is still "deleted"
- Lesson 1691 — Idempotent Request Design
- Depth limiting
- Depth limiting is simpler: the server counts how many levels deep a query nests and rejects anything beyond a maximum depth (commonly 5-10 levels).
- Lesson 1544 — Query Complexity and Depth Limiting
- Descent
- Descent is the distance below the baseline, reserved for letters that hang down like 'g', 'y', or 'p'.
- Lesson 1302 — Measuring Font Metrics: Ascent, Descent, and Line Gap
- description
- A plain-text summary of what your app does (think of it as your app's elevator pitch)
- Lesson 2304 — Categories and Description
- Design Phase
- Accessibility starts with wireframes and mockups. Designers should plan sufficient color contrast, visible focus indicators, and clear visual hierarchies before a single line of code is written.
- Lesson 994 — Accessibility in the Development Lifecycle
- Development Phase
- As you build features—whether forms, navigation, or interactive components—you apply semantic HTML, ARIA attributes, and keyboard support from day one. This is where concepts like proper labels, error message association, and focus management (which you've already learned) become part of your standard coding practice.
- Lesson 994 — Accessibility in the Development Lifecycle
- device pixel ratio
- This is called device pixel ratio (DPR).
- Lesson 1217 — Device Pixel Ratio and srcset
- dialog
- A dialog is a conversation window that opens on top of your main content.
- Lesson 1148 — Dialog vs Modal: Semantic Differences
- Direct binding
- Direct binding means calling addEventListener() on each element individually.
- Lesson 767 — Delegation vs Direct Binding
- disabled attribute
- The disabled attribute is a native HTML feature that actually prevents interaction.
- Lesson 1025 — aria-disabled vs disabled Attribute
- Disabled State
- The button is visible but grayed out and unresponsive. Use this when you want users to know an action exists but understand they can't perform it:
- Lesson 1655 — Action Button States
- disclosure widget
- A disclosure widget is simply content that toggles visibility—think FAQ accordions or "Show more" buttons.
- Lesson 1172 — Disclosure Widgets vs True Menus
- Display-P3
- Display-P3 is a wider color space that can display about 25% more colors than sRGB.
- Lesson 491 — Understanding Color Spaces: sRGB, Display-P3, and Beyond
- distance fraction
- The distance fraction is the greatest distance any unstable element moved, divided by the viewport's largest dimension (width or height).
- Lesson 1896 — Calculating CLS: Impact Fraction and Distance Fraction
- Document Object Model
- The Document Object Model is a programming interface that represents your HTML document as a tree of objects.
- Lesson 662 — What is the DOM and Why It Exists
- Document Type Declaration
- The Document Type Declaration (or DOCTYPE) is the very first line you write in an HTML file.
- Lesson 79 — The Document Type Declaration
- Documentation sites
- Documentation sites are another ideal match.
- Lesson 1822 — When Jamstack Fits Best
- DOM-based
- Each element is accessible to screen readers and can be styled with CSS
- Lesson 2601 — SVG Fundamentals for Data Visualization
- Domain
- The span of your input data ([0, 1000000])
- Lesson 2630 — Scales: Mapping Data to Visual Properties
- Domain set explicitly
- Cookie is sent to that domain and all subdomains (Domain=example.com means both api.example.com and www.example.com can access it)
- Lesson 1602 — Domain and Path Restrictions for Cookies
- DOMPurify
- DOMPurify is the gold-standard library for client-side HTML sanitization.
- Lesson 2904 — DOMPurify for HTML Sanitization
- double submit cookie pattern
- The double submit cookie pattern is a CSRF protection technique that works without server-side session state.
- Lesson 2912 — Double Submit Cookie Pattern
- downgrade attack
- This is called a downgrade attack or SSL stripping.
- Lesson 2930 — Strict-Transport-Security (HSTS) Header
- dpi
- Dots per inch. This is familiar from printing but works in CSS for screen density. 96dpi is considered standard screen resolution.
- Lesson 165 — Resolution Units: dpi, dpcm, dppx
- dppx
- Dots per pixel unit (also written as x). This is the most intuitive for web developers. A value of 1dppx means standard density, 2dppx means twice as many physical pixels per CSS pixel (like retina displays).
- Lesson 165 — Resolution Units: dpi, dpcm, dppx
- drop
- fires when item is released (access files here via event.dataTransfer.files)
- Lesson 739 — Drag and Drop EventsLesson 2675 — HTML Drag and Drop API Overview
- DSN
- The DSN (Data Source Name) is your unique project identifier from Sentry's dashboard.
- Lesson 2810 — Setting Up Sentry for Frontend
- Dynamic compression
- Dynamic compression means your server compresses files on-the-fly for each request.
- Lesson 2137 — Pre-Compression vs Dynamic Compression
- Dynamic content
- Works even for elements added after the listener is attached
- Lesson 760 — Basic Delegation Pattern
E
- ease
- The default. Starts slowly, speeds up in the middle, then slows down at the end. Natural and smooth for most transitions.
- Lesson 504 — The transition-timing-function Property
- Easier to read and maintain
- font-weight: 650; is self-explanatory
- Lesson 1290 — Standard Properties vs Variation Settings
- ecmaVersion
- The JavaScript version (3, 5, 2015-2023, or "latest")
- Lesson 1427 — Parser Options and ECMAScript Versions
- edge workers
- Edge functions (also called edge workers or edge compute) are small pieces of JavaScript code that execute at CDN edge servers—the same locations that cache your static assets.
- Lesson 2163 — CDN Edge Functions and Workers
- Efficient memory management
- Go's garbage collector is optimized for throughput, and the language encourages efficient memory usage patterns
- Lesson 1400 — esbuild: The Speed Champion
- Element
- Element is a part of a block that doesn't make sense outside that block's context.
- Lesson 596 — BEM (Block Element Modifier) MethodologyLesson 1320 — BEM Fundamentals: Block, Element, Modifier
- Elements
- Elements are specifically the HTML tags—the structural building blocks that can have attributes, classes, and IDs.
- Lesson 666 — Elements vs NodesLesson 1320 — BEM Fundamentals: Block, Element, ModifierLesson 1322 — BEM Element Naming with Double Underscores
- Elements panel
- The Elements panel is your window into the live DOM (Document Object Model) of your web page.
- Lesson 2174 — Elements Panel Overview and Navigation
- ellipsis
- Text is cut off and "..." is added to show there's more
- Lesson 248 — text-overflow and ellipsis for truncated text
- Encryption
- Encryption means all data between browser and server is scrambled using strong cryptography.
- Lesson 2927 — Why HTTPS is Essential for Modern Web Apps
- Error boundaries
- Error boundaries are React's mechanism for catching JavaScript errors anywhere in the component tree and displaying fallback UI instead of crashing the entire app.
- Lesson 1947 — Error Boundaries for Failed Chunk Loading
- Errors
- Errors are for genuine failures that break functionality:
- Lesson 2244 — console.warn and console.error
- esbuild
- esbuild is written in Go and can bundle JavaScript 10-100x faster than JavaScript-based bundlers.
- Lesson 1399 — The Modern Bundler Landscape
- Escape key handling
- The dialog closes automatically when users press Escape
- Lesson 1149 — The <dialog> Element Fundamentals
- ESM-native development
- ESM-native development means serving JavaScript modules directly to the browser without bundling them first during development.
- Lesson 1404 — ESM-Native Development
- Essential motion
- Essential motion is animation that communicates important information or aids understanding.
- Lesson 555 — Essential Motion vs Decorative Motion
- etag
- An ETag (entity tag) is a unique identifier the server sends in a response header that represents a specific version of a resource—like a fingerprint.
- Lesson 855 — Response HeadersLesson 1506 — Conditional Requests with ETag and If-None-MatchLesson 2144 — ETag and Validation
- Event delegation
- Event delegation means attaching one listener to a parent and filtering events as they bubble up.
- Lesson 767 — Delegation vs Direct Binding
- event handler function
- An event handler function is simply a JavaScript function that runs when a specific event occurs.
- Lesson 718 — Event Handler Functions
- Event handlers
- Event handlers are registered for visible page elements
- Lesson 1909 — Time to Interactive (TTI)
- eventType
- eventType is a string naming the event (without "on" prefix): "click", "mouseover", "keydown", etc.
- Lesson 717 — addEventListener() Method
- Expanded state
- aria-expanded="true" or "false" indicates whether a parent node is open
- Lesson 1201 — Tree View Pattern
- Explicit placement
- Explicit placement means you tell the browser exactly where to put each grid item using properties like grid-column, grid-row, or grid-area.
- Lesson 357 — Implicit vs Explicit Placement
- Extrinsic sizing
- Extrinsic sizing means you explicitly set the dimensions using properties like width and height.
- Lesson 151 — Intrinsic vs Extrinsic Sizing
F
- facade
- A facade is essentially a lightweight impostor that looks like the real thing but doesn't do the expensive work until necessary.
- Lesson 2050 — Script Loading Facades
- fallback
- A middle ground: brief blocking period (~100ms), then show fallback. The custom font can only swap in during a short window (~3 seconds). After that, stick with fallback until the next page load.
- Lesson 567 — The font-display Property
- Fallback Font Generator
- Fallback Font Generator is a web-based tool where you input your web font name and fallback font, and it calculates and displays the CSS you need — ready to copy and paste into your stylesheet.
- Lesson 1316 — Tools for Calculating Fallback Metrics
- fallback font stack
- A fallback font stack is a prioritized list of fonts in your CSS.
- Lesson 569 — Fallback Font Stacks
- fallback value
- A fallback value is like a safety net—you provide a simpler, widely-supported value first, then override it with the modern feature for capable browsers.
- Lesson 1366 — Fallback Values and Browser Support
- Faster TTI
- Less code to parse and execute means quicker interactivity
- Lesson 1752 — Islands Architecture
- FCP
- Think of it like a restaurant: TTFB (which you learned previously) is when the kitchen acknowledges your order, while FCP is when the first appetizer arrives at your table.
- Lesson 1731 — First Contentful Paint (FCP)
- FID historically measured interactivity
- the initial delay between when a user first interacts with your page (clicks a button, taps a link) and when the browser can actually begin processing that response.
- Lesson 1888 — The Three Core Web Vitals: LCP, FID, and CLS
- file
- The generated/compiled file this map describes
- Lesson 2279 — Source Map File Format and Structure
- Filtering
- Filtering is deciding which events to ignore completely (leaves blowing).
- Lesson 2815 — Filtering and Sampling Errors
- first argument
- The first argument is the custom element's tag name—a string that must contain a hyphen (this prevents conflicts with native HTML elements).
- Lesson 2446 — Registering Custom Elements
- First-party tracking
- First-party tracking refers to data collection by the website you're actually visiting.
- Lesson 2976 — First-Party vs Third-Party Tracking
- Fixed
- Fixed is like placing a sticker on your computer screen.
- Lesson 221 — Fixed vs Absolute Positioning
- flame chart
- Chrome DevTools' Performance panel captures this activity and displays it as a visual timeline called a flame chart.
- Lesson 1994 — Profiling Main-Thread Performance with Chrome DevTools
- flex-shrink
- item shrinks when space is tight
- Lesson 624 — Flexbox Utilities: Container and Item Properties
- Focus management hints
- The browser understands this is a special container for focus trapping
- Lesson 1149 — The <dialog> Element Fundamentals
- font-family
- The name you're giving this font (you'll reference it later in your CSS)
- Lesson 559 — The @font-face RuleLesson 564 — font-weight and font-style Mapping
- Fontaine
- Fontaine is a library that automatically generates fallback font CSS with calculated metric overrides.
- Lesson 1316 — Tools for Calculating Fallback Metrics
- Footer Links
- The most common pattern. Every page should include footer links to:
- Lesson 2959 — Privacy Policy and Terms Links
- For images
- A threshold of 0 or 0.1 works well—you want images to start loading slightly before they're needed, ensuring they're ready when users scroll to them.
- Lesson 2024 — Threshold Configuration for Loading Triggers
- Form data
- Form data is the most obvious: names, email addresses, phone numbers, addresses, payment information, and profile details all clearly identify users.
- Lesson 2956 — Personal Data in the Frontend
- fragment
- A fragment is a reusable unit of fields that you can include in multiple queries.
- Lesson 1535 — Fragments for Reusable Selections
- Fragments
- Fragments are reusable units that define a set of fields on a type.
- Lesson 1527 — Aliases and Fragments
- Framework Wrapper
- Your React app is primary, but you import a <video-player> Web Component that you also use in your marketing site (which is Vue).
- Lesson 2494 — Hybrid Approach with Frameworks
- Framework-specific tools
- Framework-specific tools are even more powerful:
- Lesson 1984 — Build-Time Critical Resource Optimization
- Freshness-based caching
- The server says "this file is good for 1 year" using headers like Cache-Control: max-age=31536000. The browser won't even check with the server during that time.
- Lesson 2141 — HTTP Caching Fundamentals
- Full SSG
- Full SSG means generating all possible pages during the build process.
- Lesson 1793 — Choosing Between Full SSG and Hybrid Approaches
- functional image
- A functional image is one that performs an action when clicked—like a button, link, or icon.
- Lesson 1139 — Alt Text for Functional Images
G
- gap
- gap is the shorthand property that sets spacing between both rows and columns simultaneously:
- Lesson 320 — Grid Gaps: gap, row-gap, column-gap
- Geographic proximity
- A user in Tokyo connects to a Tokyo edge server, not your origin server in New York
- Lesson 2157 — CDN Performance Benefits
- GET requests
- GET requests are generally safe to retry since they don't modify data.
- Lesson 1687 — Understanding When to Retry Network Requests
- Google Search Console
- Google Search Console is the official way to test and monitor your sitemap:
- Lesson 1853 — Testing and Validating CanonicalsLesson 1876 — Testing and Validating Sitemaps and Robots.txtLesson 1885 — Testing SPA SEO
- Graceful Degradation
- Graceful Degradation means building the full, feature-rich experience first (for modern browsers), then adding fallbacks so older browsers don't completely break.
- Lesson 43 — Graceful Degradation vs Progressive EnhancementLesson 2504 — Handling Unsupported Locales
- Grid
- Think of Flexbox as arranging items along a single line (like books on a shelf), while Grid is like organizing items in a complete bookshelf with multiple shelves and columns.
- Lesson 377 — When to Choose Grid Over Flexbox
- Grid areas
- Grid areas are rectangular spaces spanning one or more cells.
- Lesson 312 — Grid Lines, Tracks, Cells, and Areas
- Grid cells
- Grid cells are the individual boxes created where a row track and column track intersect.
- Lesson 312 — Grid Lines, Tracks, Cells, and Areas
- Grid lines
- Grid lines are the invisible dividing lines that create your grid's structure.
- Lesson 312 — Grid Lines, Tracks, Cells, and Areas
- Grid tracks
- Grid tracks are the spaces between two adjacent grid lines.
- Lesson 312 — Grid Lines, Tracks, Cells, and Areas
H
- handlerFunction
- handlerFunction is the function that runs when the event occurs.
- Lesson 717 — addEventListener() Method
- hash
- The hash is the part of a URL that comes after the # symbol, like https://example.com/page#section2.
- Lesson 946 — Hash Changes and Fragment Navigation
- Hashes
- Hashes are like fingerprints of exact script content.
- Lesson 2862 — Nonces vs Hashes: When to Use Each
- headers
- A Headers object containing response headers
- Lesson 831 — The Request Object and Request ConfigurationLesson 853 — Response Object Basics
- headline
- The article's title (keep it under 110 characters for best display)
- Lesson 1858 — Article Schema for Blog Posts
- Hearing impairments
- Users who are deaf or hard of hearing need captions for audio content
- Lesson 987 — What is Web Accessibility and Why It Matters
- Hidden State
- The button doesn't render at all. Use this for sensitive actions where even revealing the option could expose information:
- Lesson 1655 — Action Button States
- Highcharts
- Highcharts is the enterprise veteran—comprehensive, battle-tested, with excellent documentation and support.
- Lesson 2643 — Overview of Popular Charting Libraries
- Holy Grail Layout
- The Holy Grail Layout is a famous web design pattern with a full-width header at top, a full-width footer at bottom, and three columns in the middle (left sidebar, main content, right sidebar).
- Lesson 358 — Holy Grail Layout with Grid
- hotfix
- A hotfix is a fast-tracked patch for critical bugs — deployed outside your normal release cycle.
- Lesson 2295 — Rollback and Hotfix Workflows
- Hover states
- Hover states are perfect transition candidates:
- Lesson 2584 — Simple State Changes with Transitions
- Hreflang tags
- Hreflang tags are <link> elements placed in your HTML <head> that explicitly declare these relationships.
- Lesson 2542 — Hreflang Tags for SEO
- HTTP
- the language computers use to request and share those documents (remember the request-response cycle!)
- Lesson 28 — The Birth of the Web: Tim Berners-Lee and CERN
- HTTP headers
- Whenever your browser requests a webpage, it sends invisible metadata called HTTP headers.
- Lesson 2497 — The Accept-Language Header
- HTTPS
- HTTPS is the secure version of HTTP—the "S" stands for "Secure." It means all data traveling between your browser (client-side) and the web server is encrypted, so no one can read it if they intercept it.
- Lesson 13 — HTTPS and SSL/TLS
- Hue
- Hue is the actual color on the color wheel, measured in degrees (0-360):
- Lesson 183 — HSL and HSLA Functions
- hybrid approach
- A hybrid approach means using a framework (React, Vue, Angular) as your primary application architecture while selectively embedding Web Components for specific needs.
- Lesson 2494 — Hybrid Approach with Frameworks
- Hydration
- Hydration is the process where JavaScript "attaches" to that static HTML, binding event listeners, initializing component state, and making the page interactive.
- Lesson 1733 — Time to Interactive (TTI)Lesson 1742 — What is Hydration?Lesson 1743 — The Hydration Process FlowLesson 1753 — Resumability vs. Hydration
I
- icon
- A larger image displayed in the notification (usually 192x192 or larger)
- Lesson 2351 — Displaying Notifications with showNotification()
- ID
- A unique identifier, serialized as a String but semantically represents a unique ID (often used for cache keys)
- Lesson 1522 — Scalar Types
- Idle time
- Idle time refers to these brief windows when the browser has finished urgent work and is waiting for the next frame or user input.
- Lesson 2077 — Understanding Browser Idle Time
- image
- A full-width banner image for rich notifications
- Lesson 1858 — Article Schema for Blog PostsLesson 2351 — Displaying Notifications with showNotification()
- Imagemin
- Imagemin is a popular Node.js tool that compresses images during your build.
- Lesson 2006 — Build-Time Image Optimization Pipeline
- Immediate for Network Errors
- If an API call fails, show the error right away—don't leave the user wondering if their action is still processing.
- Lesson 1683 — Error Message Placement and Timing
- impact fraction
- The impact fraction represents the total area of the viewport that experienced instability.
- Lesson 1896 — Calculating CLS: Impact Fraction and Distance Fraction
- implicit ARIA roles
- These announcements are called implicit ARIA roles.
- Lesson 62 — Semantic Elements and Accessibility
- Implicit placement
- Implicit placement means you let the browser's auto-placement algorithm position items for you.
- Lesson 357 — Implicit vs Explicit Placement
- Important Context
- Information that helps screen reader users understand something is probably valuable to all users. If a button needs hidden text to clarify its purpose, the visible label might be too vague.
- Lesson 1135 — When NOT to Use Visually Hidden Content
- Important limitation
- Social media crawlers often don't execute JavaScript, so pure client-side updates may not work for sharing. This is why server-rendering or pre-rendering is preferred for pages you want shared.
- Lesson 1843 — Dynamic Social Meta Tags
- Indentation
- The indent rule accepts a number (spaces) or "tab", and can include options for specific scenarios like SwitchCase indentation.
- Lesson 1431 — Rule Options and Customization
- Inlining
- Inlining means embedding JavaScript directly between <script> tags in your HTML:
- Lesson 1980 — Inline vs External Critical JS
- innerText
- innerText is similar to textContent but "aware" of CSS styling.
- Lesson 694 — Setting Element Content: textContent vs innerHTML
- input group
- An input group is a common UI pattern where an input field and one or more buttons (or icons) are displayed together as if they're a single component.
- Lesson 308 — Input Groups
- Instant TTFB
- The file already exists, no computation required
- Lesson 1767 — What is Static Site Generation?
- Interpolation
- Interpolation is the process of replacing placeholders in a translation string with actual runtime values.
- Lesson 2530 — Interpolation and Variable Substitution
- Intersection Observer
- Intersection Observer is a modern API specifically designed to efficiently watch when elements enter or leave the viewport (or any ancestor container).
- Lesson 743 — Intersection Observer as Event Alternative
- Intersection Observer API
- The Intersection Observer API is a browser feature that watches elements and notifies you when they become visible (or invisible) within the viewport—without constantly checking scroll position.
- Lesson 1954 — Intersection Observer API Fundamentals
- Intrinsic sizing
- Intrinsic sizing means the element's size is determined by its content.
- Lesson 151 — Intrinsic vs Extrinsic Sizing
- Invalid credentials
- Your token is malformed, expired, or doesn't match server records
- Lesson 1657 — Understanding 401 Unauthorized
- IP addresses
- IP addresses are considered personal data under GDPR because they can identify individuals, especially when combined with other data.
- Lesson 2956 — Personal Data in the Frontend
- IP binding
- IP binding is simpler: you record the IP address when the token is issued and validate it on subsequent requests.
- Lesson 2925 — Fingerprinting and Token Binding
J
- JavaScript bundle size budget
- A JavaScript bundle size budget is a concrete, measurable limit you set on:
- Lesson 1933 — JavaScript Bundle Size Budgets
- JavaScript engine
- A JavaScript engine is a specialized program inside your browser that reads and executes JavaScript code.
- Lesson 19 — The JavaScript Engine
- JavaScript libraries and bundles
- JavaScript libraries and bundles are prime CDN targets—especially vendor code that rarely changes.
- Lesson 2158 — Types of Assets to Serve from CDNs
- Jitter
- Jitter means adding controlled randomness to your retry delays.
- Lesson 1689 — Adding Jitter to Retry Delays
- JPEG
- Quality settings typically range from 0-100. The magic zone is usually 75-85 — going from 100 to 85 can cut file size by 50% or more with minimal visible difference.
- Lesson 2004 — Quality Settings and Visual Perception
- JSON
- JSON is lightweight and perfect for modern web apps and mobile clients
- Lesson 1475 — Resource Representation
K
- Keep it minimal
- JWTs travel with every authenticated request. A bloated payload means more bandwidth and slower transmission. Only include data you'll actually check on the server.
- Lesson 1582 — Custom Claims and Payload Design
- Keep the tone friendly
- A conversational, empathetic tone ("Oops, we can't find that!") reduces user frustration compared to technical jargon.
- Lesson 1681 — Not Found and Resource Errors
- key
- The storage key that changed (or null if clear() was called)
- Lesson 776 — The storage EventLesson 2234 — Inspecting localStorage and sessionStorage
- Keyboard accessibility
- Elements like <button> and <a> are focusable by default
- Lesson 997 — Why Semantic HTML Matters for Accessibility
- keypress
- keypress is a deprecated event that used to fire between keydown and keyup for character keys only.
- Lesson 731 — Keyboard Events: keydown, keyup, keypress
L
- LAB
- LAB is the original, while OKLAB is a refined version with better uniformity—colors that look equally different have more consistent numeric differences.
- Lesson 494 — LAB and OKLAB Color Functions
- Larger initial payload
- More bytes to download before the page is visible
- Lesson 1745 — The Double Data Problem
- lazy
- Defers loading until the element is close to the viewport
- Lesson 1249 — Understanding Native Lazy Loading
- LCP measures loading performance
- specifically, how long it takes for the largest visible content element to render on screen. This is usually your hero image, main heading, or primary content block.
- Lesson 1888 — The Three Core Web Vitals: LCP, FID, and CLS
- leaves
- The leaves are the small, simple elements at the ends of branches—buttons, icons, input fields.
- Lesson 2491 — Leaf vs Container Components
- left
- The element floats to the left side of its container, and other content wraps around its right side
- Lesson 238 — Float Values and Element Behavior
- Left side
- The DOM tree—a hierarchical view of all HTML elements
- Lesson 2174 — Elements Panel Overview and Navigation
- Legitimate interest
- Legitimate interest means you have a valid business reason to process data, and your interest doesn't override the user's rights.
- Lesson 2960 — Legitimate Interest vs Consent
- Letter spacing
- Letter spacing is common for uppercase headings, logos, or creating specific typographic effects
- Lesson 170 — Letter Spacing and Word Spacing
- Level AA
- Level AA is the recommended target for most websites.
- Lesson 989 — WCAG Conformance Levels: A, AA, and AAA
- Level AAA
- Level AAA represents the highest level of accessibility.
- Lesson 989 — WCAG Conformance Levels: A, AA, and AAA
- Leverage browser caching
- Your vendor/common chunks should rarely change. Splitting third-party libraries separately means users download them once, then cache them across visits.
- Lesson 1950 — Code Splitting Trade-offs and Best Practices
- light
- the user prefers light themes (the default assumption)
- Lesson 399 — prefers-color-scheme for Dark Mode
- Light DOM
- Light DOM is the regular, familiar DOM tree — the one you see in your HTML, the one accessible to external CSS and JavaScript.
- Lesson 2460 — Shadow DOM vs Light DOM
- Lighthouse
- Lighthouse is built into Chrome DevTools (under the Lighthouse tab).
- Lesson 1318 — Testing and Measuring Font-Related CLS
- Lightness
- Lightness is how bright the color is, also a percentage:
- Lesson 183 — HSL and HSLA Functions
- Limit font variations
- Each weight/style is a separate file—only load what you actually use
- Lesson 572 — Web Font Best Practices Checklist
- line-height
- The most common example. When unitless, it multiplies the element's font size:
- Lesson 162 — Zero Values and Unitless Numbers
- linear
- The animation moves at a constant speed from start to finish. Like a robot's movement: perfectly steady but a bit unnatural.
- Lesson 504 — The transition-timing-function Property
- lines themselves
- The align-content property controls how those lines themselves are spaced along the cross axis.
- Lesson 262 — Multi-Line Alignment with align-content
- lint-staged
- lint-staged is the smart assistant that says "only check the files being committed right now" instead of your entire codebase.
- Lesson 1460 — Pre-commit Hooks with Husky and lint-staged
- listbox
- A listbox is an interactive widget that presents a list of options to the user, similar to a native <select> element but with more visual flexibility and control.
- Lesson 1200 — Listbox Pattern
- live NodeList
- A live NodeList is like a window looking directly at the DOM tree.
- Lesson 669 — Live vs Static NodeLists
- Local Network Connections
- If a user is connected to a WiFi router that has no internet access (maybe the ISP is down), navigator.onLine still returns true. The browser sees a network interface and assumes connectivity.
- Lesson 1699 — Limitations of Browser Offline Detection
- locale
- A locale is a set of parameters that defines a user's language, region, and cultural conventions.
- Lesson 2496 — Understanding Locales and Language Tags
- localhost
- This lets you view and test your website privately, using a special address called localhost.
- Lesson 14 — Localhost and Development Servers
- localStorage
- Alternative persistent storage, though cookies are more common for consent since they're automatically sent to servers.
- Lesson 2917 — Token Storage Options: localStorage vs sessionStorage vs MemoryLesson 2970 — Storing and Respecting Consent Choices
- localStorage and sessionStorage
- localStorage and sessionStorage are JavaScript-only.
- Lesson 824 — Security and Privacy Considerations
- localStorage with JSON
- (No). → localStorage with JSON is a strong choice.
- Lesson 826 — Decision Framework
- Location Header
- The URI of the newly created resource (e.g., /api/users/42)
- Lesson 1484 — POST: Creating Resources
- logpoint
- A logpoint is a special kind of breakpoint that logs information to the console instead of pausing execution.
- Lesson 2256 — Logpoints for Non-Breaking Inspection
- long task
- A long task is any JavaScript execution that occupies the main thread for more than 50 milliseconds.
- Lesson 2067 — What is a Long Task?
- long tasks
- These are called long tasks, and they're performance killers.
- Lesson 2057 — Identifying Main-Thread Blocking
- lozad
- lozad is the minimalist option — a tiny library (under 2KB) that uses the Intersection Observer API you've already learned.
- Lesson 1260 — Lazy Loading Library Options
M
- Magic comments
- Magic comments are special JavaScript comments you place inside the import() call to give those chunks meaningful names and configure how they're handled.
- Lesson 1944 — Webpack Magic Comments for Chunk Naming
- main axis
- The main axis is the primary direction your flex items flow.
- Lesson 256 — The Main Axis and Cross Axis
- main thread
- The main thread is like the brain of your web page—a single JavaScript execution thread that handles nearly everything users see and interact with.
- Lesson 1985 — Understanding the Main Thread and Browser Rendering PipelineLesson 2055 — What is the Main Thread?
- Maintain easier
- enhancing is cleaner than constantly overriding previous styles
- Lesson 380 — Mobile-First Philosophy
- Margin
- Margin is the wall space separating this frame from others
- Lesson 139 — The Box Model: Content, Padding, Border, Margin
- Match the context
- The same image needs different alt text depending on its purpose.
- Lesson 1138 — Writing Descriptive Alt Text
- Match your deployment cadence
- If you deploy weekly, checking every hour is overkill. Align update frequency with your actual release schedule.
- Lesson 2434 — Update Frequency Best Practices
- max-aspect-ratio
- Applies when viewport is at most this wide relative to height
- Lesson 396 — Aspect Ratio Media Features
- max-height
- Viewport is no taller than this
- Lesson 150 — Min and Max DimensionsLesson 394 — Width and Height Media Features
- max-width
- Viewport is no wider than this
- Lesson 150 — Min and Max DimensionsLesson 288 — min-width and max-width with FlexboxLesson 390 — Media Query Syntax and StructureLesson 394 — Width and Height Media Features
- maxEntries
- The maximum number of cached items. When exceeded, the oldest entries are removed first (LRU: Least Recently Used).
- Lesson 2409 — Cache Expiration Policies
- memory
- Think of these like house keys: localStorage is leaving a key under the doormat (convenient but risky), sessionStorage is carrying keys in your pocket (safer, but you need them each trip), and memory is memorizing combinations (most secure, but inconvenient if you forget).
- Lesson 2917 — Token Storage Options: localStorage vs sessionStorage vs Memory
- menu button
- A menu button is a button that, when clicked, reveals a menu of options (like a dropdown navigation or kebab menu).
- Lesson 1164 — Menu Button Semantics and ARIA
- meta description
- A meta description is a short summary of your webpage that appears in search engine results beneath your page title.
- Lesson 85 — Meta Description for SEO
- method
- The HTTP method to use, typically GET or POST (remember these from earlier lessons!)
- Lesson 91 — The <form> Element and Form Submission
- Micro-frontend architecture boundaries
- Micro-frontend architecture boundaries are the contracts and isolation mechanisms that allow these independent pieces to operate side-by-side safely.
- Lesson 2489 — Micro-Frontend Architecture Boundaries
- min-aspect-ratio
- Applies when viewport is at least this wide relative to height
- Lesson 396 — Aspect Ratio Media Features
- min-height
- Viewport is at least this tall
- Lesson 150 — Min and Max DimensionsLesson 394 — Width and Height Media Features
- min-width
- Viewport is at least this wide
- Lesson 150 — Min and Max DimensionsLesson 288 — min-width and max-width with FlexboxLesson 390 — Media Query Syntax and StructureLesson 394 — Width and Height Media Features
- Modern browsers
- Modern browsers are your only target (no legacy support needed)
- Lesson 2745 — Choosing the Right Date Library
- Modifier
- A variation or state of a block or element. Connected with double dashes: .card--featured, .menu__item--active, .search-form--compact
- Lesson 596 — BEM (Block Element Modifier) MethodologyLesson 1320 — BEM Fundamentals: Block, Element, Modifier
- multi-CDN strategy
- A multi-CDN strategy means distributing your content across two or more CDN providers simultaneously.
- Lesson 2164 — Multi-CDN Strategies
- mutations
- In GraphQL, mutations are operations that change data on the server—think creating, updating, or deleting records.
- Lesson 1538 — Understanding GraphQL Mutations
N
- Name
- The filename (string) without the full path for security reasons
- Lesson 2196 — Network Panel Overview and InterfaceLesson 2298 — Name and Short NameLesson 2667 — Accessing Selected Files
- named slot
- A named slot is a <slot> element with a name attribute that acts as a labeled placeholder in your Shadow DOM.
- Lesson 2477 — Basic Slot Usage: Named Content Projection
- Narrator
- Narrator is Microsoft's built-in Windows screen reader.
- Lesson 1100 — Screen Reader Landscape Overview
- Navigation Menu Pattern
- This is for groups of links that navigate somewhere, like a site's main navigation with category dropdowns. These use standard semantic HTML (<nav>, <ul>, <li>, <a>) and might use aria-expanded to indicate state. Users expect to Tab through links, not use arrow keys.
- Lesson 1163 — Accessible Dropdown Patterns Overview
- Navigation menus
- Navigation menus are typically announced as links within a navigation region.
- Lesson 1169 — Navigation Menus vs Application Menus
- Near the Source
- Place error messages directly adjacent to the field, button, or component that triggered them. For form inputs, this typically means immediately below or above the input field.
- Lesson 1683 — Error Message Placement and Timing
- Network tab
- The Network tab is crucial for understanding when resources come from cache.
- Lesson 2425 — Debugging Cache Strategies
- Network-First Strategy
- The Network-First Strategy is a Service Worker caching pattern that attempts to fetch resources from the network first, and only falls back to the cache if the network request fails.
- Lesson 2153 — Network-First Strategy
- Network-level failures
- Network-level failures are usually safe to retry:
- Lesson 1687 — Understanding When to Retry Network Requests
- Network-Only Strategy
- The Network-Only Strategy means your service worker intercepts a request but always forwards it to the network, never checking or storing it in the cache.
- Lesson 2391 — Network-Only Strategy
- newValue
- The new value (as a string, or null if removed)
- Lesson 776 — The storage EventLesson 2452 — attributeChangedCallback: Reactive Attributes
- No domain specified
- Cookie is only sent to the exact host that set it (www.example.com only)
- Lesson 1602 — Domain and Path Restrictions for Cookies
- No Long-Term Trends
- Each run is isolated; you won't see performance changes over time or across different pages without manual tracking.
- Lesson 2232 — Lighthouse Limitations and Complementary Tools
- Non-Blocking Overlays
- Non-Blocking Overlays are the most common approach: a banner appears at the bottom or top of the viewport, allowing users to scroll and view content behind it.
- Lesson 2967 — Cookie Banner Placement and Timing
- nonce
- A nonce (number used once) is a random, unique token generated on the server for each page load.
- Lesson 2854 — Understanding CSP Nonces
- Nonces
- Nonces are like unique, single-use tickets generated fresh on every page load.
- Lesson 2862 — Nonces vs Hashes: When to Use Each
- normal
- Default; no containment. The element is not a query container.
- Lesson 177 — Font Variant and Small CapsLesson 432 — Setting Up Container Context
- Normal flow
- Normal flow is the default way browsers display HTML elements when you don't apply any special CSS layout properties.
- Lesson 207 — What is Normal Flow?
- NotFoundError
- The file can't be located (perhaps deleted after selection but before reading)
- Lesson 2696 — FileReader Error Handling
- NotReadableError
- The file exists but can't be read (permissions issue or hardware failure)
- Lesson 2696 — FileReader Error Handling
- Nuxt
- The @nuxtjs/critters module handles critical CSS automatically
- Lesson 1984 — Build-Time Critical Resource Optimization
O
- object types
- In GraphQL, object types are the building blocks of your schema.
- Lesson 1523 — Object Types and Fields
- Official plugins
- Official plugins are maintained by the Vite team and cover major frameworks:
- Lesson 1383 — Vite Plugins
- Offsets
- Offsets are only safe for instantaneous timestamps that won't be interpreted in different contexts
- Lesson 2752 — Named Timezones vs Offsets
- OKLAB
- LAB is the original, while OKLAB is a refined version with better uniformity—colors that look equally different have more consistent numeric differences.
- Lesson 494 — LAB and OKLAB Color Functions
- oldValue
- the previous value (or null if first set)
- Lesson 776 — The storage EventLesson 2452 — attributeChangedCallback: Reactive Attributes
- open
- The shadow root is accessible via element.shadowRoot from outside JavaScript. This is the most common choice and enables debugging and testing.
- Lesson 2461 — Creating a Shadow Root
- Operable
- Operable means users must be able to operate the interface.
- Lesson 988 — The Four Principles of WCAG: POUR
- Optical sizing
- Optical sizing is a feature in some variable fonts that automatically adjusts these subtle design details based on the text size.
- Lesson 577 — Optical Sizing with font-optical-sizing
- Optimal Caching
- Since content is pre-built, aggressive browser and CDN caching is straightforward. Files can be cached indefinitely with cache-busting via filename hashing.
- Lesson 1723 — SSG Performance Characteristics
- origin server
- The origin server is where your CDN fetches the original files.
- Lesson 2160 — CDN Configuration Basics
P
- Padding
- Padding is perfect for internal spacing without affecting item-to-item relationships
- Lesson 139 — The Box Model: Content, Padding, Border, MarginLesson 265 — Flexbox and the Box Model
- Page-level headers
- The main header at the top of your website containing your logo, site title, and primary navigation
- Lesson 47 — The <header> Element
- Painting
- Painting is when the browser fills in pixels—turning boxes into actual visual content.
- Lesson 2217 — Paint and Composite Layers
- Partial hydration
- Partial hydration is a selective approach where you identify which components actually need interactivity and only hydrate those specific pieces.
- Lesson 1750 — Partial Hydration Concepts
- paused
- The animation stops in place but remembers its current position
- Lesson 524 — The animation-play-state Property
- Perceivable
- Perceivable means users must be able to perceive the information presented.
- Lesson 988 — The Four Principles of WCAG: POUR
- performance budget
- A performance budget is a set of predefined constraints you impose on your website's performance characteristics.
- Lesson 1929 — What is a Performance Budget?
- Periodic Background Sync
- Periodic Background Sync is fundamentally different.
- Lesson 2341 — One-off Sync vs Periodic Background Sync
- Photographs
- Complex images with thousands of colors and gradients are better as JPEG/WebP
- Lesson 1244 — SVG: Scalable Vector Graphics for the Web
- PNG-24
- Supports 16.7 million colors (24-bit RGB) with full alpha transparency (256 levels of opacity). This gives you smooth, anti-aliased edges and gradients. Perfect for logos and graphics needing subtle transparency, but file sizes are significantly larger.
- Lesson 1998 — PNG: Transparency and Quality
- PNG-8
- Supports 256 colors (8-bit), similar to GIF. Ideal for simple graphics, icons, and small UI elements with limited color palettes. File sizes are smaller, but transparency is binary (fully opaque or fully transparent—no smooth edges).
- Lesson 1998 — PNG: Transparency and Quality
- Polling
- Polling means repeatedly fetching data at regular intervals (every few seconds, for example).
- Lesson 872 — Real-Time Communication PatternsLesson 1563 — Polling and Refetching
- Position wisely
- Top bars are more noticeable; bottom bars less intrusive
- Lesson 1702 — Offline UI Indicators
- POST
- POST is like filling out a form at the library to request a new book.
- Lesson 8 — HTTP Methods: GET and POST
- Precaching
- Precaching is like packing essentials before a trip.
- Lesson 2420 — When to Use Each Strategy
- prefetch
- Remember: preload is for resources needed on the current page, while prefetch is for future pages.
- Lesson 1964 — Prefetch for Future Navigation
- preload
- Remember: preload is for resources needed on the current page, while prefetch is for future pages.
- Lesson 1964 — Prefetch for Future Navigation
- Preprocessor variables
- Preprocessor variables are replaced during build time and don't exist in the final CSS
- Lesson 467 — What are CSS Custom Properties?Lesson 477 — Custom Properties vs Preprocessor Variables
- Preserve log
- Preserve log is a DevTools setting that maintains console output across page loads, redirects, and refreshes.
- Lesson 2195 — Preserving Log and Console Settings
- Primary metric
- The main thing you care about (conversion rate, revenue per user, signup completions)
- Lesson 2825 — A/B Testing Fundamentals
- Privacy compliance
- Many third-party services collect user data. GDPR and privacy regulations require you to know exactly what trackers are present.
- Lesson 2209 — Tracking Third-Party Requests
- private
- private means only the user's browser can cache this (not shared CDNs or proxies).
- Lesson 2142 — Cache-Control Directives
- progressive enhancement
- This progressive enhancement means users don't face a "freeze" waiting for full hydration.
- Lesson 386 — Mobile Performance ConsiderationsLesson 1752 — Islands ArchitectureLesson 1754 — Streaming SSR and Hydration
- propagation
- This is called propagation—like ripples spreading across a pond.
- Lesson 1812 — Custom Domains and DNS
- Proper form state preservation
- Proper form state preservation means saving entered data, validation results, and the user's position in multi-step forms before updating the interface language.
- Lesson 2512 — Handling Language Change in Forms
- Providing context
- Providing context is crucial—include screenshots, character limits, and notes about where text appears.
- Lesson 2537 — Collaboration with Translators and Translation Services
- purging
- For production (your live website), Tailwind uses a process called purging or tree-shaking to scan your HTML, JavaScript, and template files, keeping only the utility classes you actually use.
- Lesson 616 — Development vs Production Builds
- PWAs
- PWAs are significantly lighter (typically 1-10MB cached), share browser resources, and update automatically.
- Lesson 2365 — Performance Characteristics
Q
- Query complexity
- Query complexity refers to calculating a "cost" for each query based on the fields requested and their relationships.
- Lesson 1544 — Query Complexity and Depth Limiting
- QUIC
- HTTP/3 takes a revolutionary approach: it abandons TCP entirely and runs over UDP using a new protocol called QUIC (Quick UDP Internet Connections).
- Lesson 2127 — HTTP/3 and QUIC Protocol
- Quota
- The maximum allowed storage (varies by device, available disk space, and browser)
- Lesson 2241 — Storage Quota and Usage Analysis
- Quotes
- The quotes rule can enforce "single", "double", or "backtick" quotes throughout your code.
- Lesson 1431 — Rule Options and Customization
R
- Range
- The span of your output visual property ([0, 400])
- Lesson 2630 — Scales: Mapping Data to Visual Properties
- rangeUnderflow
- True when a number is below the min attribute.
- Lesson 903 — Validity Properties Explained
- Raster images
- Raster images are made of a fixed grid of colored pixels, like a mosaic or digital photograph.
- Lesson 1239 — Understanding Raster vs Vector Image Formats
- Readable code
- tomato is easier to understand than #FF6347
- Lesson 180 — Color Keywords and Named Colors
- readonly
- Only for reading data. Multiple readonly transactions can run simultaneously. This is the default mode.
- Lesson 788 — Transactions: Read, Write, and Lifecycle
- real lock
- The real lock is on the backend—that's your true security layer.
- Lesson 1638 — Security Considerations for Frontend Authorization
- Recharts
- Recharts is React-native and composable, using SVG and a declarative component API.
- Lesson 2643 — Overview of Popular Charting Libraries
- Reduced network hops
- Fewer routers between user and content means lower latency
- Lesson 2157 — CDN Performance Benefits
- Redundant Labels
- If you're tempted to add visually hidden text that simply repeats what's already on screen, stop. Instead, make sure the visible text is descriptive enough for everyone.
- Lesson 1135 — When NOT to Use Visually Hidden Content
- Refetching
- Refetching means manually triggering a fresh data fetch, usually in response to user actions like pulling to refresh or clicking a reload button.
- Lesson 1563 — Polling and Refetching
- Reflecting
- Reflecting means writing code to keep them in harmony.
- Lesson 2456 — Reflecting Properties to Attributes
- Refresh token revocation
- Refresh token revocation means maintaining a server-side record of which refresh tokens are still valid, then actively invalidating them when needed.
- Lesson 1613 — Refresh Token Revocation
- Registering
- Registering is the critical step that connects your JavaScript class to an HTML tag name, making it usable throughout your application.
- Lesson 2446 — Registering Custom Elements
- Registration status
- Whether the worker is installing, waiting, or active
- Lesson 2238 — Service Worker Registration and Lifecycle
- removals
- Announce when elements are removed from the live region
- Lesson 1027 — aria-atomic and aria-relevantLesson 1114 — aria-relevant for Filtering Changes
- Renderer Process
- The chef—draws and displays web page content (one per tab usually)
- Lesson 17 — Browser Architecture Overview
- rendering pipeline
- The rendering pipeline is the sequence of steps browsers follow to display each frame:
- Lesson 2592 — The Rendering Pipeline
- Reproduction strategies
- Reproduction strategies are systematic techniques to bridge this gap and make bugs appear in your controlled development space.
- Lesson 2288 — Reproduction Strategies
- Request Headers
- Look for Access-Control-Request-Method and Access-Control-Request-Headers to see what your browser is asking permission for
- Lesson 869 — Debugging CORS Issues
- Request table columns
- Each row is one network request. Default columns include:
- Lesson 2196 — Network Panel Overview and Interface
- resolution switching
- Resolution switching means delivering appropriately-sized images based on the user's screen dimensions and device capabilities.
- Lesson 1212 — The Resolution Switching ProblemLesson 2007 — Responsive Images: Why Resolution Switching Matters
- Respect the 24-hour browser default
- Browsers automatically check for updates at least once per 24 hours during navigation. For many apps, this is perfectly adequate.
- Lesson 2434 — Update Frequency Best Practices
- Resumability
- Resumability is like loading a save file—you instantly start from where they left off.
- Lesson 1753 — Resumability vs. Hydration
- Review
- Review represents a single review from one person, while AggregateRating summarizes all reviews with an average score and total count.
- Lesson 1863 — Review and Rating Schema
- right
- The element floats to the right side of its container, and other content wraps around its left side
- Lesson 238 — Float Values and Element Behavior
- Robust
- Robust means content must work reliably across different technologies, especially assistive technologies like screen readers.
- Lesson 988 — The Four Principles of WCAG: POUR
- rollback
- A rollback means reverting to the last known-good version of your application.
- Lesson 2295 — Rollback and Hotfix Workflows
- rows
- Think of a virtual grid as nested virtualization: you calculate which rows are visible (just like vertical scrolling), then for each visible row, calculate which columns are visible horizontally.
- Lesson 2103 — Virtual Grid Layouts
- running
- The animation plays normally (this is the default)
- Lesson 524 — The animation-play-state Property
- Runtime caching
- Runtime caching is different—it caches resources dynamically as users request them during normal app usage.
- Lesson 2419 — Runtime Caching FundamentalsLesson 2420 — When to Use Each Strategy
S
- same-origin policy
- The same-origin policy is a critical security feature that restricts how web pages from different origins can access each other's data.
- Lesson 778 — Security and Same-Origin PolicyLesson 824 — Security and Privacy Considerations
- Sampling
- Sampling is recording only a percentage of repetitive events (record every 10th car passing, not all 10,000).
- Lesson 2815 — Filtering and Sampling Errors
- Sanitization library
- Rich text where some HTML is needed
- Lesson 2903 — Safe Alternatives to Dangerous APIs
- Saturation
- Saturation is the intensity or vibrancy, expressed as a percentage:
- Lesson 183 — HSL and HSLA Functions
- Scalable
- Stateless design means servers handle requests independently
- Lesson 1470 — What is REST and Why It Matters
- schema evolution
- GraphQL takes a different philosophy called schema evolution.
- Lesson 1550 — Versioning: REST APIs vs GraphQL Schema Evolution
- Scrollable region identification
- If your modal has a scrollable section (like a content area separate from header/footer), ensure screen readers announce it properly. The entire dialog is already focusable, so internal scrolling typically requires no extra ARIA.
- Lesson 1160 — Scrolling and Large Modal Content
- Search and replace
- Search and replace is your first line of defense: scan your codebase for http:// patterns in HTML, CSS, and JavaScript.
- Lesson 2929 — Upgrading Resources to HTTPS
- second
- The two time values can be tricky: the first time is always duration, the second (if present) is delay.
- Lesson 525 — The animation Shorthand
- second argument
- The second argument is the class you defined that extends HTMLElement or a built-in element.
- Lesson 2446 — Registering Custom Elements
- Section 508
- Section 508 is a U.S. federal law requiring government agencies and their contractors to make electronic and information technology accessible.
- Lesson 991 — Legal Requirements and Standards Compliance
- sectioning roots
- Certain elements are called sectioning roots because they create their own independent outline contexts.
- Lesson 61 — Sectioning Roots and Outlines
- Security
- If an access token is compromised, it expires quickly, minimizing damage. Even if stolen from memory or intercepted mid-request, the attacker's window is very short.
- Lesson 1605 — Why Refresh Tokens Exist
- selection
- In D3, a selection is a group of DOM elements that you want to manipulate.
- Lesson 2629 — Selections and the Enter-Update-Exit Pattern
- Semantics
- Semantics means "meaning." When HTML is semantic, it describes the purpose of content.
- Lesson 39 — HTML's Role: Document Structure and Semantics
- separation of concerns
- This separation of concerns is fundamental to modern web development.
- Lesson 38 — HTML, CSS, and JavaScript: The Three Pillars
- Server-side
- Server-side refers to code that runs on the web server before anything gets sent to you.
- Lesson 12 — Client-Side vs Server-Side
- Server-side evaluation
- Server-side evaluation means your backend determines flag states before sending HTML or API responses to the client.
- Lesson 2820 — Client-Side vs Server-Side Feature Flags
- service worker
- A service worker is a special JavaScript file that runs in the background of your web app, separate from the main browser thread.
- Lesson 2308 — What Service Workers Are and Why They Matter
- session window
- A session window is a period of layout shifts with gaps no longer than 1 second between them, capped at a maximum duration of 5 seconds.
- Lesson 1897 — CLS Thresholds and Session Windows
- sessionStorage
- Think of these like house keys: localStorage is leaving a key under the doormat (convenient but risky), sessionStorage is carrying keys in your pocket (safer, but you need them each trip), and memory is memorizing combinations (most secure, but inconvenient if you forget).
- Lesson 825 — Cross-Tab and Offline ScenariosLesson 2917 — Token Storage Options: localStorage vs sessionStorage vs Memory
- Shadow DOM
- Shadow DOM is a web standard that creates an isolated DOM subtree attached to an element.
- Lesson 2459 — What is Shadow DOM and Why It ExistsLesson 2460 — Shadow DOM vs Light DOM
- shadow root
- A shadow root is the entry point to a shadow DOM tree.
- Lesson 2461 — Creating a Shadow Root
- SharedWorker
- A SharedWorker is different—it's a worker that can be accessed by multiple browsing contexts (tabs, windows, iframes) from the same origin.
- Lesson 2093 — Shared Workers for Cross-Tab Communication
- Short expiration times
- Make tokens expire quickly (5-15 minutes), so logout just means "stop issuing new tokens"
- Lesson 1574 — Session Invalidation and Logout
- Show user notification
- Inform users certain features are unavailable
- Lesson 2797 — Error Handling for External Scripts
- siblings
- In HTML, elements at the same level sharing the same parent are called siblings.
- Lesson 124 — Combinators: Adjacent and General Sibling
- signature
- The signature (third part) is the security seal.
- Lesson 1579 — JWT Structure: Header, Payload, and Signature
- sitemap
- A sitemap is a file (typically XML format) that lists all the important pages on your website, serving as a roadmap for search engines.
- Lesson 1869 — What is a Sitemap and Why It Matters
- sitemap index file
- A sitemap index file is a master sitemap that references other sitemaps.
- Lesson 1872 — Sitemap Index Files for Large Sites
- skin
- Structure refers to layout properties (width, height, padding, margins), while skin refers to visual appearance (colors, borders, shadows, fonts).
- Lesson 597 — OOCSS (Object-Oriented CSS) Principles
- Skip links
- Skip links are visible (or become visible on focus) links at the top of your page that let keyboard users immediately jump past repetitive content.
- Lesson 1071 — Skip Links vs Landmarks
- software
- The software is the chef who takes orders and prepares dishes
- Lesson 10 — What is a Web Server?
- Source file
- The JavaScript file powering the worker
- Lesson 2238 — Service Worker Registration and Lifecycle
- source map
- A source map is a JSON file (typically with a .map extension) that acts like a translation dictionary between minified/transpiled code and your original source.
- Lesson 2279 — Source Map File Format and Structure
- Source maps
- Source maps are special files (.map) that act as translation dictionaries between minified code and your original source code.
- Lesson 2276 — Debugging Minified Code with Step Debugging
- space-evenly
- All gaps are equal—between items and at the edges.
- Lesson 274 — justify-content: Main Axis Alignment
- spacing and layout utilities
- But spacing and layout utilities are tedious to rewrite constantly.
- Lesson 604 — Mixing Methodologies Pragmatically
- SSR Approach
- The server sends fully-rendered HTML including your hero image or main text block already in the markup. The browser can start rendering the largest content immediately while JavaScript hydrates in the background.
- Lesson 1732 — Largest Contentful Paint (LCP)
- stack frame
- Think of it like a stack of plates: each time a function is called, a new "plate" (called a stack frame) is added to the top.
- Lesson 2270 — The Call Stack and Stack Frames
- state
- A JavaScript object containing any data you want to associate with this history entry (retrieved later if the user navigates back)
- Lesson 962 — history.pushState() Fundamentals
- State management
- tracking whether the listbox is expanded, which option has focus, and what text is entered
- Lesson 1198 — Combobox Pattern Fundamentals
- Stateful authentication
- Stateful authentication means the server stores session data.
- Lesson 1567 — Stateful vs Stateless Authentication
- Stateless authentication
- Stateless authentication means the server stores nothing.
- Lesson 1567 — Stateful vs Stateless Authentication
- Statelessness
- Statelessness means the server doesn't remember anything about previous requests from a client.
- Lesson 1473 — Statelessness in REST APIs
- Static files
- Static files are created with the latest content baked in
- Lesson 1781 — Headless CMS Integration FundamentalsLesson 2158 — Types of Assets to Serve from CDNs
- static frontend
- Your static frontend is pre-built and served from a CDN
- Lesson 1817 — Decoupling Frontend from Backend
- static NodeList
- A static NodeList is like a photograph of the DOM at one specific moment.
- Lesson 669 — Live vs Static NodeLists
- Status indicators
- Whether your service worker is active, waiting, or installing
- Lesson 2322 — Testing Service Workers Locally
- stored XSS
- While reflected XSS (from our previous lesson) requires tricking individual users to click malicious links, stored XSS is far more severe.
- Lesson 2894 — Stored XSS Attacks
- Structure
- Structure refers to layout properties (width, height, padding, margins), while skin refers to visual appearance (colors, borders, shadows, fonts).
- Lesson 597 — OOCSS (Object-Oriented CSS) Principles
- Style attributes
- Style attributes are CSS rules applied directly to an HTML element:
- Lesson 2883 — Style Attributes vs Style Tags
- Style tags
- Style tags are <style> elements containing CSS rules:
- Lesson 2883 — Style Attributes vs Style Tags
- Stylelint
- Stylelint is a linter—a tool that automatically checks your CSS code against rules you configure.
- Lesson 1330 — Enforcing Naming Conventions with Linters
- SVG icons
- SVG icons are individual files or symbols, easier to version control, update independently, and integrate into build pipelines with standard optimization tools.
- Lesson 2042 — Icon Fonts vs SVG Icons
- synchronous blocking behavior
- This is called synchronous blocking behavior.
- Lesson 2791 — Script Tag Basics and Execution Order
- system font stack strategy
- A system font stack strategy means carefully selecting and ordering system fonts (like Arial, Segoe UI, or San Francisco) that closely match your web font's visual characteristics—especially character width and weight.
- Lesson 1309 — System Font Stack Strategy
- System fonts
- System fonts are the typefaces already installed on a user's computer or device — like Arial, Times New Roman, or Georgia.
- Lesson 558 — Introduction to Web Fonts
T
- tab
- Each clickable tab button gets this role. These are typically <button> elements that control which panel is visible.
- Lesson 1176 — Semantic HTML Structure for Tabs
- tabpanel
- The content area associated with each tab. When a tab is selected, its corresponding panel becomes visible.
- Lesson 1176 — Semantic HTML Structure for Tabs
- tag manager
- A tag manager is a container system that lets you deploy and manage third-party scripts (called "tags") through a single, centralized interface—without directly editing your website's code.
- Lesson 2801 — What is a Tag Manager and Why Use One
- tag type
- In Google Tag Manager, a tag type is a template for deploying specific third-party scripts or tracking code.
- Lesson 2805 — Common Tag Types
- Tags
- Think of it like a smart home system: Variables are the sensors (detecting temperature, motion, light), Triggers are the conditions ("when motion detected AND after 6pm"), and Tags are the actions (turn on lights, send notification).
- Lesson 2802 — Google Tag Manager ArchitectureLesson 2804 — Tags, Triggers, and Variables
- TalkBack
- TalkBack is Google's screen reader for Android devices.
- Lesson 1100 — Screen Reader Landscape Overview
- Test with actual screen readers
- The only way to know if you've created spam is to experience it yourself using NVDA or VoiceOver.
- Lesson 1124 — Avoiding Announcement Spam
- Testing
- Testing is critical: use browser DevTools' Console and Network tabs to spot any remaining HTTP requests after deployment.
- Lesson 2929 — Upgrading Resources to HTTPS
- Text alignment
- Text alignment is controlled by text-anchor:
- Lesson 2608 — SVG Text and Labels in Charts
- text nodes
- Even the text "Hello" and "World" are nodes—called text nodes
- Lesson 663 — The DOM Tree Structure
- Text-based formats
- Text-based formats are highly compressible because they contain lots of repetition and patterns:
- Lesson 2135 — What to Compress and What Not to Compress
- Theming
- Theming means defining your visual language once and applying it everywhere.
- Lesson 2650 — Theming and Custom Styles
- Think of it like colored glass
- A solid background is like painted wood, but transparent backgrounds are like tinted windows—you can see through them to what's behind.
- Lesson 192 — Background Color and Transparency
- Think of it like this
- ARIA is a patch kit, not a replacement toolkit. Using duct tape on an already-working pipe just adds mess. Only use ARIA when semantic HTML can't do the job, and always test that your additions actually improve the experience rather than breaking it.
- Lesson 1037 — Common ARIA Anti-Patterns to Avoid
- Thumbnail Facades
- Replace the iframe with a static thumbnail image. Only when the user clicks do you inject the real iframe. This is called a "facade pattern."
- Lesson 2834 — YouTube and Vimeo Embeds
- Time Delay
- Load analytics after the critical page content is ready
- Lesson 2049 — Lazy Loading Third-Party Scripts
- Time-dependent values
- Time-dependent values are the biggest culprit.
- Lesson 1747 — Avoiding Hydration Mismatches
- Timeouts
- The server might be slow or overloaded. Retry with longer delays or fewer attempts.
- Lesson 1693 — Conditional Retries Based on Error Type
- timezone offset
- A timezone offset is the difference between UTC and a local timezone, expressed in hours and minutes:
- Lesson 2747 — Understanding UTC and Timezone Offsets
- Timezone-aware operations
- Timezone-aware operations are central to your app (booking systems, global scheduling)
- Lesson 2745 — Choosing the Right Date Library
- Timing
- Show immediately when offline is detected; confirm briefly when back online
- Lesson 1702 — Offline UI Indicators
- Total Blocking Time
- Total Blocking Time is a performance metric that measures the total amount of time the main thread was blocked during the critical period between First Contentful Paint (FCP) and Time to Interactive (TTI).
- Lesson 1736 — Total Blocking Time (TBT)
- total page weight budget
- A total page weight budget is the maximum combined size of all resources your page delivers—HTML, CSS, JavaScript, images, fonts, videos, and everything else.
- Lesson 1935 — Total Page Weight Budgets
- touches
- An array-like list of all active touch points on the screen (for multi-touch gestures)
- Lesson 757 — Event Object Properties for Different Event Types
- Translation
- Translation means shifting an element from its original position along the X-axis (horizontal) and/or Y-axis (vertical).
- Lesson 529 — 2D Translation with translate()
- Tree-shaking
- Tree-shaking is the process of eliminating unused code from your final bundle—like shaking a tree to drop dead leaves while keeping the live branches.
- Lesson 2744 — Tree-Shaking and Bundle Size
- Triggers
- Think of it like a smart home system: Variables are the sensors (detecting temperature, motion, light), Triggers are the conditions ("when motion detected AND after 6pm"), and Tags are the actions (turn on lights, send notification).
- Lesson 2804 — Tags, Triggers, and Variables
- trunk and branches
- The trunk and branches are the structural containers that hold everything together and manage complex state.
- Lesson 2491 — Leaf vs Container Components
- TTF
- TTF (TrueType Font) is the original desktop font format.
- Lesson 560 — Font File Formats: WOFF2, WOFF, TTF, EOT
- turn
- The most intuitive unit. One turn equals one complete rotation. 0.5turn is half a circle, 1turn brings you back to the start, and 2turn means two full spins.
- Lesson 163 — Angle Units: deg, rad, grad, turn
- type
- The MIME type (string) like "image/png" or "application/pdf", though it can be empty if the browser can't determine it
- Lesson 2667 — Accessing Selected Files
- type specimen
- A type specimen is like a menu at a restaurant — it shows all your available typography styles in one place so designers and developers can see exactly what they're working with.
- Lesson 594 — Documentation and Type Specimens
- Type-safe
- The ID! declares the expected type and that it's required
- Lesson 1532 — Query Arguments and Variables
U
- Understandable
- Understandable means both the information and the operation of the interface must be clear.
- Lesson 988 — The Four Principles of WCAG: POUR
- Unregister and Hard Reload
- Unregister and Hard Reload is your nuclear option—it removes the service worker entirely and forces a fresh start.
- Lesson 2440 — Unregister and Hard Reload
- Unused keys
- Translations that exist but are never referenced in code (dead weight)
- Lesson 2536 — Translation Coverage and Missing Key Detection
- URL
- The new URL to display in the address bar (must be same-origin)
- Lesson 1 — What is the Internet?Lesson 776 — The storage EventLesson 853 — Response Object BasicsLesson 961 — The History Stack and Navigation StatesLesson 962 — history.pushState() FundamentalsLesson 963 — history.replaceState() for Modifying Current Entry
- urql
- urql is ideal for medium-sized projects that need caching and state management but want to stay lightweight.
- Lesson 1565 — When to Use Which Client
- User properties
- User properties are user-scoped attributes that describe who the user is across all sessions:
- Lesson 2786 — Custom Dimension and User Properties
- User warnings
- Alert users when forms are submitted over HTTP
- Lesson 2932 — Detecting HTTPS in JavaScript
- User-agent
- Specifies which crawler the rules apply to (* means all crawlers, or you can target specific bots like Googlebot)
- Lesson 1873 — Robots.txt Fundamentals
- UTC offset
- A UTC offset is a simple number: how many hours (and minutes) ahead or behind UTC a location is at this moment.
- Lesson 2752 — Named Timezones vs Offsets
- UTF-8
- UTF-8 is a universal character encoding standard that supports virtually all written languages, symbols, and emoji.
- Lesson 82 — Character Encoding with <meta charset>
- Utility classes
- Utility classes are single-purpose classes that apply one specific style, like .text-center or .mb-2 (margin-bottom).
- Lesson 1328 — Utility Classes vs BEM Components
- utility-first CSS
- Think of building a house: component-based CSS is like ordering pre-fabricated room modules (a complete kitchen, bathroom, etc.), while utility-first CSS is like having a toolbox of individual materials (bricks, pipes, tiles) you assemble yourself.
- Lesson 654 — Utility-First vs Component-Based CSS: Understanding the Trade-offs
V
- Valid Token Acceptance
- First, verify legitimate requests work. Submit forms and make AJAX calls with proper CSRF tokens. All should succeed with 200 status codes. If these fail, your protection is too strict and breaks normal functionality.
- Lesson 2916 — Testing CSRF Protection
- Value
- The stored data (also always a string, even if it looks like JSON)
- Lesson 2234 — Inspecting localStorage and sessionStorage
- Value column
- The stored data (objects, arrays, primitives)
- Lesson 2235 — IndexedDB Inspection and Debugging
- valueMissing
- true if a required field is empty
- Lesson 902 — The Validity State ObjectLesson 903 — Validity Properties ExplainedLesson 913 — Validity State Properties
- Variables
- Think of it like a smart home system: Variables are the sensors (detecting temperature, motion, light), Triggers are the conditions ("when motion detected AND after 6pm"), and Tags are the actions (turn on lights, send notification).
- Lesson 2804 — Tags, Triggers, and Variables
- Version changes
- New app version means old cached assets are obsolete
- Lesson 813 — Deleting Cached Entries
- Virtualization
- Virtualization means only drawing data points currently in the viewport.
- Lesson 2652 — Performance with Large Datasets
- visible focus indicator
- A visible focus indicator is the visual cue (typically an outline or border) that shows which element currently has keyboard focus.
- Lesson 1054 — The Importance of Visible Focus Indicators
- Visual impairments
- Users who are blind or have low vision use screen readers that convert text to speech or braille
- Lesson 987 — What is Web Accessibility and Why It Matters
- VoiceOver
- VoiceOver is Apple's built-in screen reader for macOS and iOS.
- Lesson 1100 — Screen Reader Landscape Overview
- VPN or Proxy Issues
- The device might have a network connection, but intermediate networking layers could be blocking your specific API endpoints.
- Lesson 1699 — Limitations of Browser Offline Detection
W
- w descriptors
- w descriptors are like saying "use the highway or local roads depending on traffic and where you're going" — the browser decides based on context
- Lesson 1218 — When to Use w vs x Descriptors
- Warnings
- Warnings are for deprecations, non-critical failures, or suspicious patterns:
- Lesson 2244 — console.warn and console.error
- Waterfall Chart
- A detailed timeline showing every single resource request—HTML, CSS, JavaScript, images, fonts—with color-coded bars indicating DNS lookup, connection time, waiting, and download phases. You instantly spot slow third-party scripts or oversized assets.
- Lesson 1925 — WebPageTest for Deep Analysis
- WeakMap
- WeakMap is perfect for attaching metadata to DOM nodes or objects you don't control:
- Lesson 2117 — WeakMap and WeakSet for Automatic Cleanup
- Web fonts
- Web Fonts are excellent precache candidates because font files rarely change and cause visible layout shifts when missing.
- Lesson 558 — Introduction to Web FontsLesson 2418 — Precaching Static Assets
- web server
- A web server is both the hardware (a computer) and software (a program) that stores website files and sends them to browsers when requested.
- Lesson 10 — What is a Web Server?
- Web Workers
- Web Workers are separate JavaScript threads that run in the background, completely independent of the main thread.
- Lesson 1992 — Moving Computation to Web WorkersLesson 2085 — What Web Workers Are and Why They Exist
- WebSockets
- A persistent, bidirectional connection. Both browser and server can send messages anytime through a single open channel. Like having an open phone line—ideal for chat apps or multiplayer games where both sides need to communicate freely.
- Lesson 872 — Real-Time Communication Patterns
- Where to go
- The domain name (which DNS converts to an IP address)
- Lesson 7 — The Request-Response Cycle
- Word spacing
- Word spacing is less frequently adjusted but useful for justified text or stylized quotes
- Lesson 170 — Letter Spacing and Word Spacing
- Work offline
- Serve cached responses when the network is unavailable
- Lesson 809 — What is the Cache API and Why It Matters
- Workbox
- Workbox is a powerful library created by Google that abstracts away the complexity of writing service workers from scratch.
- Lesson 2404 — What is Workbox and Why Use It
- Workspace Settings
- Workspace Settings are stored inside a specific project folder (in .vscode/settings.json).
- Lesson 1467 — Workspace Settings vs User Settings
X
- x descriptors
- x descriptors are like saying "always take Route 2" — you're specifying exactly which road for which situation
- Lesson 1218 — When to Use w vs x Descriptors
Y
- y position
- chartHeight - (value × scale) (SVG's origin is top-left, so you flip it)
- Lesson 2605 — Creating Bar Charts with SVG
Z
- Zero persistence
- The user must log in again after every page refresh or browser restart. There's no "remember me" functionality—it's like writing notes on a whiteboard that gets erased when you leave the room.
- Lesson 1598 — Memory-Only Token Storage