Web Site Development Industry Terminology

A/B Testing

A controlled experiment comparing two variants of a page or component to determine which performs better against a defined metric (e.g., conversion rate).

- Let's run an A/B test on the hero headline to see which version drives more sign-ups. - The B variant improved the click-through rate by 12%. - We need a statistically significant sample size before declaring a winner.

Accessibility (a11y)

The practice of designing and building websites usable by people with disabilities. Encompasses semantic HTML, ARIA, color contrast, keyboard navigation, captions, and adherence to standards like WCAG.

- Add ARIA labels to improve a11y for screen reader users. - We must meet WCAG 2.2 AA for this public-sector project. - Keyboard-only navigation is failing our accessibility audit.

Agile

An iterative approach to project management and software development emphasizing collaboration, incremental delivery, adaptability, and continuous improvement (e.g., Scrum, Kanban).

- We'll refine the backlog during Agile sprint planning. - Let's ship an MVP this sprint and iterate based on feedback. - For maintenance work, we're switching to Kanban instead of Scrum.

API

Application Programming Interface: a set of rules for programs to communicate, commonly via HTTP (REST or GraphQL) to retrieve or modify data and trigger operations.

- Integrate the payment API before launch. - Our public API rate limit is 100 requests per minute. - Expose a POST /orders endpoint for order creation.

Backend

The server-side part of a web application responsible for business logic, databases, authentication, and APIs.

- Move the business logic to the backend for security. - The backend is throwing intermittent 500 errors. - We'll deploy the backend as a Node/Express service.

Browser Developer Tools (DevTools)

Built-in browser tools (e.g., Chrome DevTools, Firefox Developer Tools) for inspecting DOM/CSS, debugging JavaScript, profiling performance, and analyzing network requests.

- Check the console errors in DevTools. - Use the Network tab to profile slow requests. - Simulate mobile viewports in DevTools for responsive testing.

Build Pipeline

Automated steps that transform source code into deployable artifacts (e.g., compile, bundle, minify, test) and deliver them via CI/CD.

- Add linting and unit tests to the build pipeline. - The pipeline failed due to a flaky end-to-end test. - Set up GitHub Actions for CI and Vercel for deployments.

Caching

Storing frequently accessed data closer to the user or application to reduce latency and load (browser cache, CDN cache, server-side cache).

- Set Cache-Control and ETag headers for static assets. - Bust the cache after deploying new CSS. - Add Redis to cache expensive queries.

CDN (Content Delivery Network)

A geographically distributed network of servers that caches and serves content from locations closer to users to improve performance and reliability.

- Serve images and fonts via the CDN. - Purge the CDN cache after a content update. - Use edge functions on the CDN for personalization.

CMS (Content Management System)

Software that allows non-developers to create, manage, and publish website content. Can be traditional (coupled) or headless (API-driven).

- Marketing needs a CMS to manage blog posts. - We’re migrating to a headless CMS for flexibility. - Define the content model in the CMS before templating.

Core Web Vitals

Google’s key user-centric performance metrics: LCP (Largest Contentful Paint), CLS (Cumulative Layout Shift), and INP (Interaction to Next Paint).

- Our LCP is failing Core Web Vitals on mobile. - Reduce layout shift to improve CLS. - INP spiked after we added a chat widget; investigate event handlers.

CSS (Cascading Style Sheets)

A stylesheet language used to describe the presentation of HTML, including layout, colors, and typography.

- Refactor CSS into modules to avoid global leaks. - Use Flexbox and Grid for layout. - Avoid using !important; increase specificity instead.

DevOps

A culture and set of practices that integrate software development and IT operations to shorten development cycles and increase deployment frequency and reliability.

- We’re adopting DevOps to shorten lead time and improve reliability. - Automate deployments and rollbacks via CI/CD. - Add observability: logs, metrics, and tracing.

DNS (Domain Name System)

The system that translates human-readable domain names into IP addresses and directs traffic using records like A, AAAA, CNAME, MX, and TXT.

- Update the A record to point to the new IP. - Set a CNAME to the CDN hostname. - DNS propagation can take up to 24 hours.

Docker

A platform for packaging applications and their dependencies into portable containers that run reliably across environments.

- Dockerize the app for consistent environments. - Use a multi-stage Dockerfile to reduce image size. - Run integration tests with Docker Compose.

Environment Variables

Key-value configuration injected at runtime to keep secrets and environment-specific settings out of source code.

- Store API keys in environment variables, not in code. - Use a secrets manager for production env vars. - Configure separate envs: development, staging, production.

FCP (First Contentful Paint)

A performance metric measuring the time from navigation until the first text or image is painted on screen.

- Preload critical fonts to improve FCP. - FCP regressed after we added a heavy slider. - Measure FCP in Lighthouse and field RUM.

Framework

A structured foundation of tools and conventions (front-end or back-end) that accelerates development and enforces patterns.

- Decide between React and Vue for the front-end framework. - Use Express as the server framework. - Schedule framework upgrades quarterly to stay secure.

Front-End

The client-facing part of a website or app built with HTML, CSS, and JavaScript that runs in the browser.

- The front-end uses React with Vite for bundling. - Fix the routing bug in the front-end. - Optimize the front-end bundle size by code splitting.

GDPR (General Data Protection Regulation)

EU regulation governing personal data privacy and protection, affecting consent, data processing, user rights, and data transfers.

- Implement a consent banner to comply with GDPR. - Sign a DPA with analytics vendors. - Provide data export and deletion workflows for users.

Git

A distributed version control system for tracking changes in source code and enabling collaboration via branching and merging.

- Open a pull request and request review. - Rebase before merging to keep history clean. - Tag the release v1.2.0.

GraphQL

A query language and runtime for APIs that lets clients request precisely the data they need in a single round trip.

- Define a GraphQL schema and resolvers. - Use fragments to avoid overfetching. - Persisted queries help with caching and security.

Headless CMS

A CMS that provides content via APIs without a built-in presentation layer, enabling decoupled front-end architectures.

- Fetch content from the headless CMS at build time. - Use webhooks to trigger rebuilds on publish. - Editors manage content without touching the front-end code.

HTML (HyperText Markup Language)

The standard markup language for structuring web content using elements like headings, paragraphs, links, and forms.

- Use semantic HTML elements for better a11y. - Fix invalid HTML attributes flagged by the validator. - Add alt text to images for screen readers.

Hosting

The infrastructure and services used to serve a website or app to users (shared hosting, VPS, serverless, managed platforms).

- Move hosting to a managed platform for better uptime. - Configure autoscaling to handle traffic spikes. - Set up a custom domain and HTTPS on the hosting provider.

IA (Information Architecture)

The organization and labeling of content to support findability and usability, including navigation structures and sitemaps.

- Simplify the IA to reduce deep navigation levels. - Run a card-sorting exercise to inform the IA. - Deliver a sitemap and navigation schema as IA outputs.

i18n (Internationalization)

Preparing an application to support multiple languages and locales, including text, dates, currencies, and directionality.

- Externalize strings and keys for i18n. - Use ICU message formats for pluralization. - Ensure layouts support RTL languages like Arabic.

Jamstack

An architecture that decouples the front end from the back end, emphasizing pre-rendering, CDNs, and APIs for performance and scalability.

- Build a Jamstack site with static generation and serverless functions. - Leverage the CDN for speed and resilience. - Use incremental static regeneration for content updates.

JavaScript

The programming language of the web used for dynamic behavior on the client and increasingly on servers via Node.js.

- Avoid blocking JavaScript on the critical rendering path. - Use async/await for cleaner async code. - Lint JS with ESLint and enforce code style.

JSON (JavaScript Object Notation)

A lightweight, text-based data interchange format that is easy for humans to read and for machines to parse and generate.

- Return JSON from the API endpoints. - Validate payloads with JSON Schema. - GZIP-compress JSON responses to save bandwidth.

KPI (Key Performance Indicator)

Quantifiable metrics used to evaluate the success of a website or project (e.g., conversions, bounce rate, page speed).

- Define KPIs like conversion rate and average order value. - Review KPIs weekly on the dashboard. - Align OKRs with the site's KPIs.

Kubernetes

An orchestration system for automating deployment, scaling, and management of containerized applications.

- Deploy the app to a Kubernetes cluster. - Use rolling updates to avoid downtime. - Configure an Ingress for HTTPS routing.

LCP (Largest Contentful Paint)

A Core Web Vitals metric that measures when the largest visible content element renders, reflecting loading performance.

- Preload the hero image to improve LCP. - Serve responsive images in AVIF/WebP. - Reduce render-blocking CSS to speed up LCP.

Lighthouse

An automated tool from Google for auditing performance, accessibility, SEO, and best practices of web pages.

- Run Lighthouse in CI to catch regressions. - Our Lighthouse performance score dropped after adding custom fonts. - Use the treemap to spot bundle bloat.

Minification

The process of removing whitespace, comments, and unnecessary characters from code to reduce file size without changing functionality.

- Minify CSS and JS to reduce payload size. - Enable HTML minification in the build. - Verify sourcemaps work after minification.

Mobile-First Design

A design approach that prioritizes small screens and touch interactions first, then progressively enhances for larger screens.

- Start with mobile breakpoints and scale up. - Use min-width media queries for a mobile-first CSS strategy. - Prioritize tap targets and performance on mobile.

Node.js

A JavaScript runtime built on Chrome's V8 engine that lets you run JS on the server, enabling full-stack JS development.

- Implement SSR with Node.js for faster TTI. - Use Node streams for efficient file uploads. - Upgrade to the latest Node.js LTS.

NPM (Node Package Manager)

The default package manager for Node.js used to install, manage, and publish JavaScript packages.

- Pin dependencies in package-lock.json for reproducible builds. - Run npm audit to find vulnerabilities. - Use npm scripts to orchestrate builds and tests.

OAuth 2.0

An authorization framework enabling third-party applications to obtain limited access to HTTP services without sharing credentials.

- Implement the Authorization Code flow with PKCE for the SPA. - Store and refresh tokens securely. - Request only the minimal scopes needed.

On-Page SEO

Optimizing individual web pages (content, HTML tags, structure) to rank higher and earn more relevant traffic in search engines.

- Write unique title tags and meta descriptions. - Add schema.org structured data for rich results. - Improve internal linking to key pages.

PWA (Progressive Web App)

A web application that uses progressive enhancement to deliver app-like experiences with offline support, push notifications, and installability.

- Add a service worker and web app manifest. - Enable offline caching with Workbox. - Prompt users to Add to Home Screen on mobile.

QA (Quality Assurance)

Processes and testing practices to ensure a website meets requirements, is reliable, and is free of critical defects.

- Create acceptance criteria and test cases for each story. - QA sign-off is required before release. - Maintain automated regression tests.

React

A popular JavaScript library for building component-based user interfaces with a virtual DOM and unidirectional data flow.

- Use hooks instead of class components. - Lazy-load routes to reduce initial bundle size. - Lift state up to avoid prop drilling.

Responsive Web Design (RWD)

An approach where layouts and content adapt fluidly to different screen sizes and orientations using media queries and flexible grids.

- Test RWD across common breakpoints and devices. - Use CSS Grid and flexible images for responsive layouts. - Ensure the viewport meta tag is configured correctly.

REST API

An architectural style for APIs that uses stateless HTTP requests, resources, and standard methods (GET, POST, PUT, DELETE).

- Design RESTful endpoints with proper nouns and verbs. - Return accurate HTTP status codes and error bodies. - Document the API with OpenAPI/Swagger.

SEO (Search Engine Optimization)

The practice of improving a website to increase organic visibility in search engines through technical, on-page, and off-page tactics.

- Fix crawl errors in Google Search Console. - Improve E-E-A-T signals with authoritative content. - Optimize for featured snippets on target queries.

Server-Side Rendering (SSR)

Rendering HTML on the server and sending it to the client to improve perceived performance and SEO, then hydrating with client-side JS.

- Use SSR to improve time-to-content and SEO. - Cache SSR HTML at the edge for speed. - Hydrate components on the client after SSR.

SSL/TLS

Cryptographic protocols that secure HTTP traffic (HTTPS) by encrypting data in transit and authenticating servers (and sometimes clients).

- Enable HSTS to enforce HTTPS. - Auto-renew Let's Encrypt certificates. - Prefer TLS 1.3 and modern cipher suites.

TTFB (Time to First Byte)

A performance metric measuring the time from a request being made to the first byte of the response being received by the browser.

- Reduce TTFB with edge caching. - Optimize server processing time and DB queries. - Monitor TTFB in real user monitoring dashboards.

TypeScript

A typed superset of JavaScript that compiles to plain JS, improving developer productivity and reliability through static typing.

- Add TypeScript to our React codebase for safer refactors. - Define interfaces for API responses. - Enable strict mode to catch null/undefined bugs.