The Web Design & Development Glossary

The quiet success code: the request worked and the response contains what you asked for. It’s the status behind every page that simply loads — you never notice it precisely because everything’s fine.

A 301 is a permanent server-side redirect that sends both visitors and search engines from an old URL to a new one. When a page or whole domain moves, a proper 301 passes along the link authority the old URL earned, so bookmarks, inbound links and rankings follow you to the new address instead of dying in a 404.

A redirect meaning “what you want is over here for now — check back at this address next time.” Unlike a 301, it doesn’t pass along ranking authority, so it’s the wrong tool for a permanent move.

The server’s way of saying “nothing’s changed since you last asked — use your cached copy.” It saves bandwidth and speeds up repeat visits by not re-sending files the browser already has.

The server couldn’t understand the request because it was malformed — a garbled URL, bad syntax, or missing data. The problem is on the sending end, not the server.

You need to log in, or your credentials were wrong. Despite the name it really means “unauthenticated” — the server doesn’t know who you are yet.

The server knows who you are and still won’t let you in. Access is denied — common when a file’s permissions are locked down or a security rule blocks the request.

The internet’s most famous error: the server is fine, but there’s nothing at the address you asked for — a mistyped URL, a deleted page, or a broken link. A good site turns its 404 page into a helpful detour (search, popular links) instead of a dead end, and 301-redirects URLs that have genuinely moved so it never loses the traffic.

The URL exists, but you’re using the wrong kind of request on it — e.g. sending form data (POST) to a page that only serves content (GET). A classic when a static host receives a form submission it isn’t set up to handle.

Like a 404, but deliberate and permanent: this resource existed and has been intentionally removed for good. Telling search engines “410 Gone” gets a dead page de-indexed faster than a 404.

A real (joke) status code from a 1998 April Fools’ spec — a teapot refusing to brew coffee. It does nothing useful, but it’s a beloved bit of web folklore you’ll occasionally spot in the wild.

You’re being rate-limited — sending requests faster than the server allows, so it’s asking you to slow down. Common with APIs and as a defense against abuse and scraping.

The catch-all “something broke on our end” code. The server hit an unexpected problem — a bug, a crashed script, a bad database query — and couldn’t finish. Unlike a 404, the fix is server-side, and the real cause is waiting in the server logs.

One server, acting as a middleman, got an invalid response from another server upstream. Often seen when an app or origin behind a proxy or CDN is down or misbehaving.

The server is temporarily unable to handle the request — usually overloaded or down for maintenance. It’s meant to be short-lived, and a well-behaved 503 tells clients when to try again.

A middleman server waited too long for a response from an upstream server and gave up. The upstream is too slow or unresponsive — a timeout rather than an outright refusal.

A DNS record that maps a domain name to an IPv4 address — the line that says “example.com lives at this server.” (Its IPv6 cousin is the AAAA record.) Change the A record and you change where the whole world’s browsers go when they type your name.

The part of a page a visitor sees before scrolling. The term is borrowed from newspapers. It still matters: your headline, your promise and a clear next step should live up here, because a large share of people decide whether to stay in the first few seconds.

Designing and building so that people with disabilities — visual, motor, auditory, cognitive — can actually use your site. Good accessibility (screen-reader support, keyboard navigation, sufficient contrast) is both the right thing to do and, increasingly, a legal expectation. It also tends to make a site better for everyone.

A precise, step-by-step set of instructions for solving a problem. From sorting a list to ranking search results, all software is built from algorithms — and a better one can be the difference between instant and unbearably slow.

The written description attached to an image (alt="..."). Screen readers read it aloud, search engines use it to understand the picture, and it’s what shows if the image fails to load. Describe what the image communicates, not just what it literally is.

The visible, clickable words of a link. “Click here” tells a search engine nothing; descriptive anchor text (“our Shopify setup guide”) tells both people and Google what’s on the other end.

Application Programming Interface — a defined way for two pieces of software to talk to each other. When your contact form sends mail through SendGrid, or your store pulls live shipping rates, it’s happening over an API. APIs are how modern sites stitch services together instead of building everything from scratch.

A specific value you hand to a function when you call it — the actual input it works on. (The named placeholder in the function’s definition is the “parameter”; the value you pass in is the argument.)

Accessible Rich Internet Applications — a set of HTML attributes (role, aria-label, aria-expanded…) that describe interactive widgets to assistive technology. The first rule of ARIA is to use native HTML where you can and reach for ARIA only when you can’t.

An ordered list of values stored under one name, each reachable by its position (index). Arrays are a fundamental way to hold a collection of things — a list of products, a set of dates — and loop over them.

Code that doesn’t wait. Instead of freezing while a slow task (like fetching data) finishes, asynchronous code starts it and carries on, handling the result whenever it arrives. It’s what keeps a page responsive while things load in the background.

Everything that runs on the server, out of the visitor’s sight: databases, application logic, APIs, authentication. The backend decides what data to show; the frontend decides how it looks.

A link from another website to yours. Search engines treat them as votes of confidence: the more relevant, trustworthy sites that point to you, the more authority you tend to accumulate. A handful of links from respected sources beats a thousand from junk.

The amount of data transferred between your site and its visitors over a period of time. Traditional hosts meter and bill it; modern static platforms like Cloudflare Pages don’t cap it at all, which is one reason a fast static site can absorb a traffic spike without a surprise invoice.

Shorthand for how an algorithm’s cost grows as the input gets bigger — whether doubling the data doubles the work (O(n)) or quadruples it (O(n²)). It’s how developers reason about whether code will still be fast at scale.

The smallest unit of digital data: a single binary digit, either 1 or 0. Everything a computer does is ultimately bits; eight of them make a byte. (Network speeds are measured in bits per second — note the lower-case “b”.)

The simplest data type: a value that is either true or false. Booleans drive every decision in code — is the user logged in? is the cart empty? — and power all conditional logic.

The share of visitors who land on a page and leave without interacting further. A high bounce rate isn’t automatically bad — someone may have gotten exactly the answer they needed — but on a sales page it usually signals a mismatch between what you promised and what they found.

More than a logo. It’s the consistent system — mark, colors, typography, voice and the feeling people get — that makes your business recognizable and trustworthy across every touchpoint, online and off.

The small “Home › Blog › This Post” trail near the top of a page. It helps visitors understand where they are and gives search engines a clear picture of your site’s structure.

A screen width at which a responsive layout changes — say, where a three-column grid collapses to one column on a phone. Good breakpoints are chosen by where the content starts to break, not by chasing specific device sizes.

A flaw in code that makes it behave incorrectly. The term famously dates to a literal moth found in a 1947 computer. Bugs are inevitable; what separates good software is how thoroughly they’re caught and fixed before users meet them.

Eight bits grouped together — enough to represent a single character like “A”. The byte is the base unit the whole data-size ladder builds on, each rung roughly 1,000× the last: KB, MB, GB, TB, PB, EB, ZB, YB.

A stored copy of content kept close to where it’s needed so it doesn’t have to be regenerated or re-fetched every time. Browsers cache assets, servers cache pages, and CDNs cache your whole site at the edge. Caching is the single biggest lever for perceived speed.

The practice of serving those stored copies. On WordPress a caching plugin turns dynamic PHP pages into static HTML so visitors aren’t waiting on the database every load; on a static or CDN-backed site, caching is essentially built in.

The specific thing you want a visitor to do next — “Get a quote,” “Add to cart,” “Book a call.” Every meaningful page should have one obvious, primary CTA. If everything is emphasized, nothing is.

A function you hand to another function to be run later, once something finishes — “call me back when you’re done.” A classic way to handle asynchronous work, now often expressed more cleanly with Promises and async/await.

The single “official” address for a piece of content when several URLs could show the same thing. A <link rel="canonical"> tag tells search engines which version to credit, preventing your own pages from competing with each other.

The broader process of collapsing the many possible forms of a URL (with/without www, with/without a trailing slash, http vs https) down to one standard form. Without it, example.com and www.example.com can be treated as two different sites splitting the same authority.

Content Delivery Network — a fleet of servers spread around the world that each keep a cached copy of your site. A visitor in Sydney is served from a nearby node instead of waiting on a server in Virginia. Cloudflare runs one of the largest; it’s why edge-hosted sites feel instant everywhere.

A blueprint for creating objects that share the same structure and behavior. Define a User class once, then stamp out many user objects from it, each with its own data. A core building block of object-oriented programming.

Command-Line Interface — controlling software by typing text commands instead of clicking a graphical interface. It looks intimidating but it’s fast, scriptable and precise; most professional development and deployment happens here.

A function that “remembers” the variables from where it was created, even after that outer code has finished running. A powerful (and famously confusing) JavaScript concept used to keep data private and build flexible behavior.

Cumulative Layout Shift — a Core Web Vital that measures how much your page jumps around as it loads. The annoying moment when you go to tap a button and an ad shoves it down? That’s CLS. Reserving space for images and embeds keeps it near zero.

Content Management System — software that lets non-developers create and edit site content without touching code. WordPress is the best-known, but the category ranges from Shopify (for stores) to headless systems that feed content to a custom front end.

A DNS record that points one name at another name rather than an IP address — e.g. www as an alias of your apex domain, or a custom domain pointed at a pages.dev host. Handy, with one classic gotcha: a strict CNAME isn’t allowed on a bare apex domain (providers like Cloudflare work around it with “CNAME flattening”).

A program that translates the code you write into a lower-level form the machine can run, all at once, ahead of time. (Compare an interpreter, which translates and runs line by line as it goes.)

Shrinking files before they’re sent. Text assets are squeezed with Gzip or Brotli; images with formats like WebP. Less data over the wire means faster loads — often the easiest performance win available.

Logic that runs different code depending on whether something is true — the if / else at the heart of every program. Conditionals are how software makes decisions instead of doing the same thing every time.

The moment a visitor takes the action that matters to you — buys, books, subscribes, fills out the form. Everything else on the site exists to make conversions more likely. Define yours before you measure anything.

The percentage of visitors who convert. If 1,000 people visit and 25 buy, that’s a 2.5% conversion rate. Doubling it is usually cheaper than doubling traffic, which is why design and copy quality pay for themselves.

A small piece of data a site stores in your browser and sends back on each visit — used to keep you logged in, remember your cart, or track preferences. Privacy laws now require consent for non-essential cookies.

Google’s trio of real-world experience metrics — loading (LCP), interactivity (INP) and visual stability (CLS). They factor into rankings and, more importantly, into whether visitors stick around. A well-built site passes them comfortably.

The control panel many traditional hosts use to manage websites, email, databases and DNS. cPanel manages a single account; WHM is the reseller/admin layer above it that creates and manages those accounts. Powerful, but a reminder that you’re on shared, server-managed infrastructure.

An automated program that visits and reads web pages — Googlebot being the famous one. Crawlers follow links, index what they find, and build the database that powers search. Your job is to make their path clear with clean links, a sitemap and sensible robots.txt rules.

Cascading Style Sheets — the language that controls how a site looks: layout, color, type, spacing, animation. HTML is the structure; CSS is the styling laid over it. Clean, well-organized CSS is the difference between a site that’s easy to evolve and one that fights every change.

See Call to Action. The single most important — and most often neglected — element on a page.

A way of organizing data so it can be used efficiently — arrays, lists, maps, trees, queues. Choosing the right structure is one of the quiet skills that separates fast, clean software from slow, tangled software.

An organized store of your site’s data — posts, products, users, orders. WordPress uses MySQL/MariaDB; every query to it takes time, which is why database-driven sites lean on caching and why a purely static site (no database to query) is inherently quicker.

Distributed Denial of Service — an attack that floods a site with bogus traffic from many machines at once to knock it offline. Sitting behind a network like Cloudflare is the standard defense; it absorbs and filters the flood before it reaches your server.

Any external code your project relies on to work — a library, a framework, a plugin. Dependencies save enormous time, but each is code you didn’t write that can break, bloat or expose your project, so they’re worth keeping lean and current.

To publish your code or content to the live environment so the public can see it. Modern workflows let you deploy in seconds and roll back just as fast — a far cry from the days of dragging files over FTP and hoping.

A generic HTML container (<div>) used to group and lay out content. It’s the workhorse of page structure — but reach for semantic elements (<header>, <nav>, <main>, <article>) first; they tell browsers and screen readers what a section actually is.

The Open Directory Project — the first large, human-edited web directory. It shaped early SEO and shut down in 2017. We list it because you’ll still bump into references to it in old advice; treat that advice with suspicion.

Domain Name System — the internet’s phone book. It translates the human name you type (wandzilakwebdesign.com) into the numeric IP address machines use. When you “point a domain” somewhere, you’re editing DNS records. Changes can take minutes to hours to propagate.

A third-party score (popularized by Moz) that estimates how likely a site is to rank, based largely on its backlink profile. It’s a useful relative gauge, not a Google metric — don’t mistake the speedometer for the engine.

Your address on the web — the name people type to reach you. You don’t buy it outright; you register it (lease it) through a registrar, typically by the year. It’s one of the few assets you should guard jealously and always control yourself.

Selling goods or services online. It spans everything from a single “Buy” button to a full catalog with inventory, payments, tax and shipping. The platform you choose — Shopify, WooCommerce, custom — should follow from how you actually sell, not the other way around.

Servers positioned geographically close to users (“the edge”) rather than in one central data center. Running your site — and even your code, via edge functions — at the edge is what makes globally fast, resilient sites possible.

A specific URL where an API can be reached to do one thing — fetch a user, create an order, send an email. An API is essentially a collection of endpoints, each a doorway to a particular action or piece of data.

A setting stored outside your code — like an API key or database password — that the app reads at runtime. Keeping secrets and per-environment config in environment variables, not hard-coded, is basic security and good practice.

About 1,000 petabytes — a unit reserved for the truly massive. Global internet traffic is measured in exabytes per month; only the largest companies and infrastructures operate at this scale.

An error that interrupts the normal flow of a program when something goes wrong — a missing file, a bad input, a failed network call. Good code anticipates exceptions and handles them gracefully (“try/catch”) instead of crashing.

The tiny icon that appears in browser tabs, bookmarks and history. A small thing that quietly signals polish; a missing favicon makes a site feel unfinished.

A Web Application Firewall inspects incoming traffic and blocks malicious requests — SQL injection, bad bots, known exploits — before they reach your site. It’s a core layer of a sensible security posture, and a managed network can run one for you.

Adobe (formerly Macromedia) Flash brought animation, sound and interactivity to the early web. Browsers killed it off for good in 2020 over security and performance. Anything Flash once did is now done better with HTML5, CSS and JavaScript — if you have Flash content lingering, it’s long past time to replace it.

Flash of Unstyled Content — the brief flicker (often a white flash) when a page’s raw HTML paints before its CSS loads. A reliable old fix is to set the background on the html element itself so the right color is painted first; modern build pipelines and inlined critical CSS prevent it more thoroughly.

A pre-built foundation of code and conventions you build on top of, instead of starting from a blank file. On the front end, React; for styling, Tailwind; on the back end, Laravel or Rails. Frameworks trade a learning curve for speed, structure and a community of solved problems.

Everything that runs in the visitor’s browser — the HTML, CSS and JavaScript that make up what they see and touch. “Front-end development” is the craft of turning a design into a fast, accessible, interactive interface.

File Transfer Protocol — the old way of moving files to a web server with a client like FileZilla. It still works, but plain FTP is insecure and manual; modern teams deploy through Git and automated pipelines, with SFTP for the rare hand-edit.

Comfortable across the whole spectrum — frontend, backend, databases, deployment. A full-stack developer can carry a feature from the database query all the way to the button you click.

A named, reusable block of code that performs a task — give it inputs, it does its job, optionally hands back a result. Functions organize a program into manageable, repeatable pieces instead of one giant wall of instructions.

Google Analytics 4 — the current version of Google’s analytics, built around events rather than the old pageview-centric model. It tells you where visitors come from, what they do, and which channels actually produce conversions. Privacy-first alternatives exist, but GA4 remains the default.

Tailoring content, ads or SEO to a specific place — a city, region or radius. Essential for local businesses: a roofer in Denver wants to be found by people searching in Denver, not nationwide.

About 1,000 megabytes (a billion bytes) — a couple of hours of HD video, or the size of a typical app or game download. The unit most people think in for phones and storage plans.

The version-control system professional developers use to track every change, work in parallel and roll back mistakes. Paired with a host like GitHub, it’s also how modern sites deploy: push your code, and the site rebuilds. If your site isn’t in version control, you’re working without a safety net.

WordPress’s block editor, introduced in 2018 — the default way content is built in modern WordPress, assembling a page from stackable “blocks” (paragraph, image, columns, etc.) rather than one freeform text area.

The main heading of a page (<h1>) — the title of its content. There should be exactly one, and headings should descend in order (H1, then H2, H3…) like an outline. It helps both readers skimming and screen-reader users navigating.

The output of a one-way function that turns any input into a fixed-length string. The same input always produces the same hash, but you can’t reverse it — which is why hashing is used to store passwords safely and verify that data hasn’t been tampered with.

A content system that manages your content but doesn’t dictate how it’s displayed — it serves the content over an API to whatever front end you build. “Headless” buys flexibility and speed at the cost of more up-front engineering.

The large, attention-grabbing area at the top of a page — usually a bold headline, a supporting line and a primary call to action, often over an image or animation. It sets the tone and makes the promise the rest of the page keeps.

The service that stores your website’s files and serves them to visitors. Options run from cheap shared hosting to VPS, managed platforms and edge networks. The right host shapes your speed, reliability and security as much as your code does.

HyperText Markup Language — the foundational language of every web page. It defines structure and meaning: headings, paragraphs, links, images, forms. CSS styles it and JavaScript animates it, but HTML is the skeleton everything hangs on.

A three-digit number a server returns with every response to say how the request went. They’re grouped by first digit: 2xx success, 3xx redirect, 4xx the client (you) made a mistake, 5xx the server did. The family alone tells you whose problem it is.

The secure version of HTTP, encrypting traffic between browser and server with TLS so it can’t be read or tampered with in transit. It’s now the baseline — browsers flag plain HTTP as “Not Secure,” and certificates are free. There’s no excuse not to have it.

Integrated Development Environment — the software developers write code in (VS Code, JetBrains and the like). It bundles an editor with autocomplete, error-checking, debugging and version control to make writing code faster and less error-prone.

The process by which a search engine stores and organizes the pages it has crawled so they can appear in results. A page can be crawled but not indexed; if it isn’t indexed, it effectively doesn’t exist in search.

In object-oriented programming, letting one class build on another — a Manager class inheriting all the traits of an Employee class and adding its own. It lets code reuse and extend behavior instead of duplicating it.

An architecture built on pre-rendered markup served from a CDN, with dynamic bits handled by JavaScript and APIs. In plain terms: ship fast static files and call services only when you need them. It’s the philosophy behind a lot of modern, edge-hosted sites.

The programming language of the browser — it makes pages interactive: menus, sliders, form validation, live updates, whole applications. With Node.js it also runs on servers. Powerful, but worth using deliberately: too much JavaScript is a leading cause of slow sites.

JavaScript Object Notation — a lightweight, human-readable format that structures data as key-value pairs. It’s the universal language APIs use to send information back and forth, and it’s everywhere in modern web development.

A word or phrase people type into search. Modern SEO is less about stuffing exact keywords and more about thoroughly answering the intent behind them — but knowing the terms your customers actually use still guides what you write.

About 1,000 bytes — roughly a page of plain text or a small icon. The first rung above the byte on the data-size ladder.

A focused page built around a single goal and usually a single offer, often the destination of an ad or campaign. Strip away distractions, make one promise, ask for one action. Specialized landing pages routinely outconvert sending traffic to a homepage.

Deferring the load of off-screen images, videos or iframes until the visitor scrolls near them. The page becomes interactive sooner and wastes no bandwidth on things never seen. Native browser support (loading="lazy") makes it nearly free.

Largest Contentful Paint — a Core Web Vital marking when the biggest element in view (usually the hero image or headline) finishes rendering. It’s a good proxy for “when does this page feel loaded?” Aim for under 2.5 seconds.

A collection of pre-written code you pull into your project to handle a common task — date formatting, charts, animation — without reinventing it. Smaller and more focused than a framework: a library is a tool you call; a framework is a structure you build inside.

Optimizing to be found by nearby customers — claiming and tuning your Google Business Profile, earning local citations and reviews, and targeting location-based searches. For brick-and-mortar and service-area businesses, it’s often the highest-ROI marketing there is.

A construct that repeats a block of code — once for each item in a list, or until a condition is met. Loops are how programs handle “do this for all of them” instead of writing the same step a thousand times.

Malicious software that can infect a site — to steal data, redirect visitors, mine crypto or spread further. Out-of-date plugins are the usual entry point on WordPress. Updates, least-privilege access, a firewall and clean backups are the defense.

The CSS feature (@media) that applies styles only under certain conditions — most often a screen width, but also things like dark mode or reduced-motion preferences. Media queries are the mechanism that makes responsive design work.

About 1,000 kilobytes (a million bytes) — a high-resolution photo, or a minute or two of MP3 audio. The unit most web-page weights are measured in.

The short summary of a page (~150–160 characters) that search engines often show beneath your title in results. It doesn’t directly affect rankings, but a sharp, benefit-led description meaningfully changes how many people click.

Code that sits in the middle of a request and response, processing it on the way through — checking you’re logged in, logging the request, parsing data — before it reaches the final handler. A clean way to layer shared logic.

Stripping the comments, whitespace and unnecessary characters out of CSS and JavaScript so the files download faster. The code still works identically; it’s just smaller. A standard step in any production build.

Model-View-Controller — a way of structuring an application by separating concerns: the Model handles data, the View handles presentation, and the Controller handles the logic connecting them. Keeping these apart makes large codebases far easier to reason about and maintain.

The DNS servers that hold the authoritative records for your domain. Pointing your domain’s nameservers at a provider (say, Cloudflare) hands them control of your DNS — the first step in putting a domain behind their network.

A fast, efficient web server (and reverse proxy) that powers a huge share of high-traffic sites, often paired with or in front of other software. Like Apache, it’s part of the plumbing your site sits on — invisible when it’s doing its job.

A runtime that lets JavaScript run on servers, not just in browsers. It made JavaScript a full-stack language and underpins a huge share of modern web tooling and back-end services.

A link attribute (rel="nofollow") that tells search engines not to pass authority through a link. It’s used for paid, untrusted or user-generated links. Most everyday internal and editorial links should be regular (“followed”) links.

A deliberate “nothing here” value — the intentional absence of data, distinct from zero or an empty string. Mishandling null (“cannot read property of null”) is one of the most common sources of bugs.

A bundle of related data and behavior grouped under one name, usually as key-value properties — a user object with a name, an email, and a method to log in. Objects are how most modern code models real-world things.

A way of organizing code around “objects” — self-contained bundles of data and behavior — rather than a long list of instructions. With classes, inheritance and encapsulation, OOP helps large codebases stay structured and maintainable.

The set of og: meta tags that control how your page looks when shared on social platforms — the title, description and preview image. Get them right and a shared link looks deliberate and clickable; ignore them and you get an ugly, blank card.

A visual site builder for WordPress that outputs notably lean markup and gives developers fine control, without the bloat some page builders add. A favorite for performance-minded WordPress work — though it ties the build to that ecosystem.

A tool that installs, updates and tracks the external libraries your project depends on — npm for JavaScript, pip for Python, and so on. It turns “hunt down and manually copy code” into a single command.

A drag-and-drop tool for designing WordPress pages without code — Elementor, Beaver Builder, Divi, Oxygen and others. They lower the barrier to editing; the tradeoff is that some add markup and scripts that can weigh a site down if used carelessly.

How quickly a page loads and becomes usable. It affects rankings, bounce rate and revenue in measurable ways. Speed comes from many small disciplines — caching, compression, image formats, lean code — and it’s a core reason to consider a static or edge-hosted build.

The service that securely processes card and digital payments on your store — Stripe, PayPal, Shopify Payments and the like. It handles the sensitive part of a transaction so you don’t have to touch raw card data. Fees and supported methods vary, so it’s worth choosing deliberately.

About 1,000 terabytes — the scale of serious data centers and large platforms. One petabyte is roughly 11,000 4K movies; a few would hold every photo a large social network receives in a day.

The server-side programming language WordPress is written in, and a long-time backbone of the web. It runs on the server to assemble pages before they’re sent to the browser. Mature and ubiquitous, if no longer fashionable.

An add-on that extends a platform’s features — a WordPress contact form, an SEO toolkit, a backup tool. Plugins are WordPress’s superpower and its biggest liability: each one is third-party code that can slow, break or expose your site, so fewer and well-chosen beats many.

An object representing a value that isn’t ready yet — the eventual result of an asynchronous task that will either resolve (succeed) or reject (fail). Promises, with async/await, are the modern, readable way to handle work that takes time.

The systematic process of testing software to make sure it meets its requirements and works correctly before users ever touch it. Good QA isn’t an afterthought bolted on at the end — it’s baked into how the thing is built.

A set of techniques for managing network traffic so the important stuff — video calls, payments — gets the speed, low latency and reliability it needs even when the network is busy. The plumbing-level discipline behind “it just works.”

A request for data from a database — “give me every order placed this week.” Usually written in a language like SQL. Every dynamic page runs queries behind the scenes, and a slow query is a common hidden cause of a slow site.

The built-in JavaScript method querySelector that finds elements on a page using CSS selectors, so code can read or change them. It’s the modern, standard way JavaScript reaches into the DOM (and the reason you rarely need jQuery anymore).

The part of a URL after the question mark, used to pass parameters to the server — ?search=boots&page=2. It’s how filters, searches and tracking tags ride along in a link. (Never put sensitive data here — it’s visible and logged.)

A data structure that processes items First-In, First-Out — like a line at a checkout. In web apps, queues hold background jobs (sending emails, resizing images, processing payments) so slow work happens out of band instead of making the user wait.

A fast, widely used “divide and conquer” sorting algorithm: pick a pivot, split everything into smaller and larger, then repeat on each half. A classic example of how a clever approach sorts data dramatically faster than checking every pair.

A program whose only output is an exact copy of its own source code — no input, no tricks. Useless in practice and beloved by programmers as a playful brain-teaser and a small monument to recursion and self-reference.

A backwards-compatibility rendering mode browsers fall into when a page lacks a proper <!DOCTYPE html>, mimicking the quirky behavior of 1990s browsers. It causes weird layout bugs — which is why every modern page declares the standard doctype to stay in “standards mode.”

The standard keyboard layout, named for the first six letters on its top row. The arrangement dates to 1870s typewriters and was reportedly designed to slow typists down so the mechanical keys wouldn’t jam — a 150-year-old constraint we all still type on.

When a function calls itself to break a problem into smaller versions of the same problem — handy for things like walking a folder tree or nested data. Powerful, elegant, and a reliable way to tie your brain in a knot the first few times.

Improving the internal structure of code — making it cleaner, simpler, faster to work with — without changing what it does from the outside. Regular refactoring keeps a codebase healthy instead of slowly rotting into “don’t touch that.”

The accredited company you register (lease) a domain through — GoDaddy, Namecheap, Cloudflare Registrar and others. They’re not all equal on price, renewal cost or honesty about upsells; the registrar that hooked you cheaply may not be the one you want to keep the name with.

A compact pattern-matching language for finding and manipulating text — validating an email, extracting every date from a document, search-and-replace on steroids. Incredibly powerful and famously cryptic to read.

Building one site that adapts fluidly to any screen — phone, tablet, laptop, big monitor — rather than maintaining separate versions. Since most traffic is mobile, “responsive” isn’t a feature anymore; it’s the baseline expectation.

A common, conventional style of web API that uses standard HTTP verbs (GET, POST, PUT, DELETE) against addressable resources. Most services you’d integrate — including WordPress itself — expose a REST API; it’s the lingua franca of system-to-system communication.

A plain text file at your site’s root that tells crawlers which areas they may or may not access. It’s guidance, not a lock — sensitive pages need real protection — but it’s how you keep bots out of admin paths and point them at your sitemap.

The environment in which code actually executes (like Node.js or the browser), and also the period when a program is running — as opposed to when it’s written or built. A “runtime error” is one that only shows up once the code is live.

Structured data (usually JSON-LD) added to your pages so search engines understand exactly what they describe — a product, a business, an FAQ, a review. It can earn you rich results (stars, prices, FAQ dropdowns) that make your listing stand out and click better.

Where in your code a given variable can be seen and used. Good scoping — keeping variables local to where they’re needed rather than global — prevents naming collisions and whole categories of bugs.

Using HTML elements for their actual meaning — <nav> for navigation, <button> for buttons, <article> for self-contained content — instead of a sea of generic <div>s. Semantic markup is more accessible, more SEO-friendly and easier to maintain, all at once.

Search Engine Optimization — the ongoing practice of earning visibility in organic (unpaid) search by making your site fast, well-structured, genuinely useful and trustworthy. It’s a compounding investment, not a switch; done right, it pays back for years.

Search Engine Results Page — what you see after a query. “SERP management” is the discipline of shaping how and where you appear there, across the organic listings, local pack, images and rich results. The whole point of SEO is to win real estate on it.

Running code without managing servers yourself — you write a function, the platform runs it on demand and scales it automatically. Cloudflare Workers and similar services let dynamic logic run at the edge, close to users, billed only when it actually runs.

A way for a server to remember a particular user across multiple requests — keeping you logged in as you move from page to page. The server tracks the session, usually via a cookie holding a unique ID.

The cheapest tier of traditional hosting, where many sites share one server’s resources. Fine for small, low-traffic sites; the catch is that a neighbor’s spike or security lapse can affect you, and performance is capped by what you’re sharing.

A hosted e-commerce platform that handles the storefront, checkout, payments, hosting and security for you, for a monthly fee. It’s the fastest reliable way to launch a serious store — the tradeoff is monthly cost, transaction fees if you skip Shopify Payments, and working within its ecosystem.

Organizing a site so that closely related pages link tightly to each other and form a clear topical cluster. Done well, siloing helps both visitors and search engines see you as a focused authority on a subject rather than a scattered collection of pages.

A file (usually sitemap.xml) listing your site’s important URLs so search engines can discover and prioritize them. It doesn’t guarantee indexing, but it’s a clear, machine-readable map you hand to Google.

Structured Query Language — the language used to read and write data in relational databases like MySQL. Every time WordPress loads a post, SQL queries run behind the scenes. (Unsanitized input near SQL is also where “SQL injection” attacks happen — hence the emphasis on secure code.)

Static Site Generator — a tool (Eleventy, Hugo, Astro, Next.js and others) that builds your site into plain HTML files ahead of time. You get the editing convenience of templates and content files, plus the speed and security of static output. Our favored approach for content sites that don’t need a live database.

The credential that enables HTTPS, verifying your site’s identity and encrypting traffic. Once a paid annual purchase, certificates are now free and auto-renewing via services like Let’s Encrypt and Cloudflare. If anyone tries to sell you one as a must-buy add-on, be skeptical.

A private copy of your live site where changes are built and tested before going public. It’s the difference between trying a risky update in front of customers and trying it where only you can see the breakage.

A site served as pre-built HTML, CSS and JavaScript files with no database or server-side processing per request. Because there’s nothing to assemble on the fly, static sites are exceptionally fast, cheap to host, and have almost no attack surface. Ideal for marketing sites, portfolios and blogs.

A piece of text — letters, numbers, symbols — treated as data: a name, a message, a URL. One of the most fundamental data types, and one you manipulate constantly (joining, splitting, searching, formatting).

A prefix on your domain that can host separate content — blog.example.com, shop.example.com, dev.example.com. Subdomains are created in DNS and are handy for staging environments, stores or apps that live alongside the main site.

Scalable Vector Graphics — images defined by math rather than pixels, so they stay razor-sharp at any size and usually weigh very little. Perfect for logos, icons and illustrations; they can even be styled and animated with CSS.

The grammar rules of a programming language — where the brackets, semicolons and keywords go. Break the syntax and the code won’t run at all; a “syntax error” is the computer refusing to read a malformed sentence.

A utility-first CSS framework: instead of writing custom stylesheets, you compose designs from small, single-purpose classes right in your markup. It makes building consistent, responsive interfaces fast — once you’re past the initial “that looks busy” reaction.

About 1,000 gigabytes (a trillion bytes) — on the order of 250 HD movies, and the capacity of a typical modern hard drive. Where personal storage and small-business backups now live.

The package that controls a site’s appearance and layout — on WordPress, Shopify and beyond. Also called a template or (in older parlance) a skin. A theme is a starting point; the value is in how well it’s adapted to your brand and content.

The <title> of a page — what shows in the browser tab and, crucially, as the bold blue headline in search results. It’s one of the strongest on-page SEO signals and your first pitch to a searcher. Make each one unique and specific.

A superset of JavaScript that adds optional “types” — labelling whether a value is text, a number, and so on — so whole classes of bugs are caught while you write rather than when users hit them. Widely adopted for larger, more reliable codebases.

User Interface — the concrete visual and interactive layer people touch: buttons, forms, menus, spacing, type. UI is part of UX. Beautiful UI on top of confusing UX is lipstick on a maze.

Automated checks that verify small, individual pieces of code (“units”) do what they should. A good test suite catches breakage the moment it happens and lets developers change code with confidence instead of crossing their fingers.

The percentage of time your site is reachable. “99.9% uptime” sounds perfect but still allows ~8.7 hours of downtime a year; the architecture you choose (single server vs. distributed edge) largely determines how close to truly always-on you get.

User Experience — the overall feel of using your site: how easily someone can find what they need and accomplish their goal. Good UX is mostly invisible; bad UX is the friction that quietly sends people to a competitor.

HTML and CSS that conform to the standards for the document type, with no structural errors when checked against a validator like the W3C’s. Valid code renders more predictably across browsers and devices and is easier to maintain. We validate as part of every build.

A named container for a value your code can read and change — like a labelled box holding a number, some text, or a whole object. Variables are the most basic building block of programming: a way to store and reuse data.

The visible area of a web page on a given device. The <meta name="viewport"> tag tells mobile browsers to render at the device’s real width instead of pretending to be a desktop — the small line that makes responsive design behave.

A real person viewing your site, as opposed to a bot crawling it. In analytics this is usually counted as a “session” — a group of interactions within a time window. Distinguishing human visits from automated traffic matters when you’re judging what’s actually working.

Virtual Private Server — a slice of a physical server with resources dedicated to you, more powerful and isolated than shared hosting and cheaper than a whole machine. It offers control and consistency, at the cost of needing someone who can manage it.

See Firewall. The shield that filters malicious requests before they reach your site.

Web Content Accessibility Guidelines — the internationally recognized standard for accessibility, organized into levels A, AA and AAA. “WCAG 2.1 AA” is the common target for compliance and the benchmark most accessibility laws point to.

The software (Apache, Nginx, Cloudflare’s edge) that receives requests and sends back your pages and files. It’s the layer between a visitor’s browser and your site’s files — usually invisible, always essential.

An automated message one service sends another when an event happens — “an order was placed,” “a form was submitted.” Where an API is you asking for data, a webhook is the data showing up the moment it’s ready. It’s how systems react to each other in real time.

A modern image format that delivers the same quality as JPEG or PNG at noticeably smaller file sizes, with transparency and animation support. Converting images to WebP (with AVIF close behind) is one of the simplest, highest-impact speed upgrades available.

A persistent, two-way connection between browser and server that stays open, letting both send messages instantly — the technology behind live chat, real-time notifications and collaborative apps, where plain request-and-response would be too slow.

A low-fidelity, deliberately plain blueprint of a page — boxes and labels, no colors or polish — used to settle structure and priority before any visual design. It’s far cheaper to move a box in a wireframe than to rebuild a finished page.

The free e-commerce plugin that turns WordPress into a full online store. It’s deeply customizable and you own everything, but you’re also responsible for hosting, security, performance and updates — the classic WordPress tradeoff applied to selling.

The open-source CMS that powers roughly 43% of all websites — by far the most popular way to build a site. It’s flexible and well-supported, with a vast plugin and theme ecosystem; the flip side is that it needs maintenance, and its strengths can become liabilities if it’s left untended.

A small piece of code that runs on a CDN’s edge network, close to your visitors, rather than on a central server. Cloudflare Workers can handle forms, redirects, authentication and whole APIs with near-zero latency — the engine behind a lot of fast, modern sites (including parts of this one).

Xerox’s legendary 1970s research lab — birthplace of the graphical user interface, the mouse, Ethernet and laser printing. Famously, the ideas walked out the door and reshaped the entire computer industry; nearly everything about how we use computers traces back here.

The original browser API for fetching data from a server in the background without reloading the page — the technology that made “AJAX” and dynamic web apps possible. Modern code mostly uses the cleaner fetch() now, but XHR is where it started.

eXtensible Markup Language — a verbose, tag-based format for structuring data (HTML’s strict, all-business cousin). Once the default for data exchange and still common in feeds, sitemaps and config files, though JSON has largely taken its place for web APIs.

A logic operation that’s true only when its two inputs differ — one or the other, but not both. A fundamental building block in low-level programming, bitwise math and cryptography.

eXtensible Stylesheet Language Transformations — a language for converting XML from one shape into another (say, raw data into HTML). Powerful and now fairly niche, but still encountered wherever heavy XML pipelines live.

Also written CSRF — an attack that tricks a logged-in user’s browser into making a request they didn’t intend (like changing their email) by riding on their existing session. Defended against with anti-forgery tokens that prove a request really came from your own site.

A common web vulnerability where an attacker sneaks malicious JavaScript into a page so it runs in other visitors’ browsers — stealing sessions, defacing content, or worse. The defense is rigorous: never trust user input, and escape everything you render.

The millennium bug: older software stored years as two digits (“99”), so “00” threatened to read as 1900 and break date math worldwide. A massive, largely successful remediation effort meant the feared meltdown mostly fizzled — a rare disaster averted by quiet, unglamorous engineering.

“You Aren’t Gonna Need It” — a programming principle that says don’t build features or flexibility until you actually need them. A guard against over-engineering: the speculative code you add “just in case” usually becomes complexity you maintain for nothing.

“YAML Ain’t Markup Language” — a clean, human-readable format for configuration files that uses indentation instead of brackets. It’s everywhere in modern tooling (Docker, CI/CD pipelines, deployment configs), prized for being easy to read and edit by hand.

A popular JavaScript package manager — an alternative to npm for installing and managing a project’s dependencies, originally built for faster, more reliable installs. Same job as npm, different tool; many projects use one or the other.

The largest standard unit of data — about 1,000 zettabytes, or a trillion terabytes. So vast it’s effectively theoretical: no single system on Earth comes close to storing one. (The ladder: KB, MB, GB, TB, PB, EB, ZB, YB.)

The CSS property that controls stacking order — which overlapping elements sit in front of which. Higher z-index wins. It’s how dropdowns, modals and tooltips float above the page (and the source of many a “why is this hidden behind that?” head-scratcher).

A security vulnerability that’s exploited before the vendor even knows about it or has a fix — defenders have “zero days” of warning. The most dangerous class of flaw, and the reason keeping software patched and layered behind defenses matters.

A unit of data equal to about 1,000 exabytes — a sextillion bytes. The world has crossed into the “zettabyte era”: the total data created and stored globally is now measured in tens of zettabytes a year. (Next rung up: the yottabyte.)

A compressed archive format that bundles many files into one smaller file — the everyday way to package and shrink things for download or transfer. “Zipping” squeezes out redundancy; the files come back intact when unzipped.

On Unix-like systems, a process that has finished running but still lingers in the process table because its parent hasn’t collected its exit status. Harmless in small numbers, but a pile-up signals a bug — code that spawns work and never cleans up after itself.