The field is wide. Here's how we move.

At Dallonses, clarity is part of how we work. We believe that when everyone on a project understands the language, better decisions get made, faster. This glossary is a small reflection of that.

Digital products are built on a shared language. Developers, designers, product managers, and clients all need to understand each other to build something that works. But that shared language isn't always obvious, especially when you're working across disciplines or stepping into a new project for the first time.

This glossary exists to bridge that gap. Whether you're a developer looking for a clear definition, a client trying to make sense of what your team is talking about, or a project manager navigating between both worlds, you'll find straightforward explanations of the terms that come up most in digital product development.

The entries here cover the full spectrum of how we work: Agile methodologies, frontend and backend technologies, testing practices, design tools, and more. Each term is explained in plain language, without unnecessary jargon, but with enough depth to be genuinely useful.

We update the glossary as the industry evolves. New frameworks emerge, practices shift, and the vocabulary of digital product development grows with them. This is a living resource, not a static document.

The hand that contains all the knowledge.

A

A/B testing: A/B testing is a controlled experiment that compares two versions of something to see which performs better. Traffic splits at random, half sees version A, half sees version B, and you measure which one moves the metric you care about. It replaces opinion with evidence.
Acceptance testing: Acceptance testing is the check that happens before something ships. Not a developer reviewing their own code. A product, feature, or system evaluated against the requirements agreed before anyone started building.
Accessibility (a11y): Accessibility, often shortened to a11y (the 11 letters between the a and the y), is the practice of building digital products that people with disabilities can actually use. That includes people who are blind or have low vision, people who are deaf or hard of hearing, people with motor impairments, and people with cognitive differences. The same work also helps people in temporary or situational contexts, like a broken arm or bright sunlight on a phone screen.
Accessibility audit: An accessibility audit is a structured review of a website or app to find the barriers that stop disabled people from using it. The benchmark is almost always the Web Content Accessibility Guidelines (WCAG), graded at levels A, AA, and AAA, with AA being the standard most laws and contracts expect. An audit checks a product against those success criteria and reports what passes, what fails, and how serious each failure is.
Agile: Agile is a set of principles and values for software development, first written down in the Agile Manifesto in 2001. It was a reaction against heavy, plan-driven methods that fell apart the moment requirements changed. The manifesto puts individuals and interactions above processes and tools, working software above documentation, customer collaboration above contract negotiation, and responding to change above following a fixed plan.
Android: Android is the mobile operating system built by Google and maintained as open source through the Android Open Source Project. It runs on more phones than any other platform on earth, plus tablets, watches, TVs, and car dashboards. The base is a Linux kernel. On top sit the runtime, the system services, and the apps people actually touch.
Angular: Angular is a web application framework built and maintained by Google. It is written in TypeScript and gives teams a full set of tools out of the box: routing, forms, HTTP, dependency injection, and a structured way to organize an app into components, services, and modules. Where some libraries hand you a few pieces and leave the rest to you, Angular makes most of the architectural decisions for you. That is the trade. Less choice, more consistency.
Apache Kafka: Apache Kafka is a distributed platform for moving streams of events between systems. Producers write records to named streams called topics, consumers read from them, and Kafka keeps the records durably and in order so many services can react to the same flow of events independently.
API: An API, short for Application Programming Interface, is a defined set of rules that lets one software system talk to another. It states what requests can be made, how to format them, and what responses come back. None of the internals are exposed. The API is a contract, and as long as both sides honour it, each system can change underneath without breaking the other.
API testing: API testing checks the application below the interface, at the layer where services exchange data. Instead of clicking through a screen, you send requests straight to an endpoint and verify the response: the status code, the body, the headers, the timing. No browser, no rendering, just the contract between systems.
Astro: Astro is a web framework built for content-driven sites that need to load fast. Blogs, marketing sites, documentation, e-commerce fronts. It ships zero JavaScript by default and only sends the code a page actually needs to be interactive.
Atomic design: Atomic design is a way of building user interfaces from the smallest parts up. Coined by Brad Frost, it borrows from chemistry: small elements combine into larger ones, which combine into full pages. The method gives teams a shared vocabulary for how an interface is assembled and how its pieces relate.
Attribution model: An attribution model is the set of rules that decides which marketing touchpoints get credit when someone converts. A customer rarely buys after a single ad. They might see a social post, search later, click an email, and finally convert through a paid link. The attribution model answers a hard question. Of all those steps, which one earned the sale, and how much.
Authentication: Authentication is the process of verifying the identity of a user, system, or device before granting access to a resource. It answers one question. Are you who you say you are? Get it right and the rest of a secure system has solid ground to stand on. Get it wrong and everything above it is exposed.
AWS: AWS is Amazon Web Services, the largest cloud provider in the world. It started in 2006 with a handful of services and now runs hundreds, covering everything from raw virtual machines to databases, machine learning, message queues, and content delivery. If a piece of digital infrastructure exists, AWS almost certainly rents a version of it.
AWS Lambda: AWS Lambda is Amazon's serverless compute service. You upload a function, define what triggers it, and Amazon runs it on demand. No servers to provision, patch, or keep warm. When nothing calls your function, you pay nothing. When a thousand requests arrive at once, Lambda spins up a thousand copies and bills you per invocation and the milliseconds each one runs.
Azure: Azure is Microsoft's cloud computing platform. It rents out computing, storage, databases, networking, AI services, and hundreds of other building blocks on demand, charged by what you use. Instead of buying servers and running a data center, a company runs its software on Microsoft's infrastructure across regions worldwide. Azure is one of the three giants in the market, alongside AWS and Google Cloud.

B

B Corp Certification: B Corp certification is a verification awarded by the nonprofit B Lab to companies that meet a high bar on social and environmental performance, accountability, and transparency. It is not self-declared. A company has to pass the B Impact Assessment, score above a set threshold, and open its operations to scrutiny across governance, workers, community, environment, and customers.
Backend: The backend is the server-side layer of an application, the part that runs on a server rather than in the user's browser or device. It stores and manages data, executes business logic, handles authentication, and answers requests from the frontend. If the frontend is the face of a product, the backend is its brain. Invisible to the user, responsible for everything that makes the thing actually work.
Big data: Big data refers to datasets so large, fast-moving, or varied that ordinary tools can't store or process them in a reasonable way. The threshold isn't a fixed number of gigabytes. It's the point where a spreadsheet or a single database stops coping and you need distributed systems built for the scale.
Bootstrap: Bootstrap is a front-end CSS framework. It ships a grid system, ready-made components like buttons, forms, modals, and navbars, and a set of utility classes you drop straight into your HTML. Born at Twitter in 2011, it became the default way to build responsive websites for years. The pitch was simple: stop writing the same layout and component CSS on every project and grab a tested, consistent set instead.
Bounce rate: Bounce rate is the share of visits where someone lands on a page and leaves without doing anything else. No second page, no tracked interaction, just arrive and go. It's long been read as a signal that a page failed to hold attention, though that reading depends heavily on context.
Branch (Git): A branch in Git is an independent line of development inside a repository. It lets a developer build a feature, fix a bug, or run an experiment in isolation, without touching the main codebase or disturbing anyone else's work. Branches are cheap to create and fast to switch between, which is why they have become the standard unit of work in almost every professional team.
Bug: A bug is an error or unintended behaviour in software that makes it produce wrong or unexpected results. The word has been used in engineering since the nineteenth century and stuck in software after a 1947 incident, when a moth was found jamming a computer relay. The question with bugs is never whether they appear. It is how fast they get caught and how much damage they do first.
Build: A build is the process of turning source code into a deployable artefact: the compiled, bundled, optimised version of an application that can actually run in a target environment. Depending on the stack, a build might compile TypeScript into JavaScript, bundle hundreds of modules into a few files, strip the code down to shrink its size, and generate the static assets ready to serve to users. The output is something you can deploy, not just something you can read.
Bun: Bun is a JavaScript runtime, the thing that executes JavaScript and TypeScript outside a browser. It competes with Node.js and Deno, but it bundles far more into one tool. A package manager, a bundler, a test runner, and a runtime, all in a single binary. The selling point is speed. Bun is written in a low-level language called Zig and built on Apple's JavaScriptCore engine rather than Google's V8, and it starts up and installs dependencies noticeably faster than Node.
Business Intelligence (BI): Business intelligence is the practice of turning a company's data into reports, dashboards, and metrics that people can actually act on. It covers the tools and processes that take raw numbers from across the business and present them as something a manager can read in a meeting and make a decision from. BI answers questions about what happened and what is happening right now.

C

Caching: Caching is storing the result of expensive work so the next request can reuse it instead of redoing it. A database query that takes 200 milliseconds runs once, the answer gets kept somewhere fast, and the next thousand requests read it in under a millisecond. The work happens once and pays off many times.
Carbon footprint: A carbon footprint is the total amount of greenhouse gases produced by an activity, product, person, or organisation, expressed as carbon dioxide equivalent (CO2e). It bundles different gases into one comparable number, so a flight, a factory, and a website can be measured on the same scale.
Carbon-aware computing: Carbon-aware computing means timing and placing computing work to use electricity when and where it's cleanest. The carbon intensity of the grid isn't constant. It swings hour by hour as wind, solar, and demand shift, and it varies widely between regions. The same job can emit far more carbon at 6pm on a still evening than it does at 3am with the wind blowing. Carbon-aware systems read that signal and act on it.
Card sorting: Card sorting is a research method for understanding how people expect information to be organised. Participants are given a set of items, each on its own card, and asked to group them in ways that make sense to them. The patterns that emerge across many participants reveal the mental model your users actually hold, which is often different from the one your org chart produces.
CDN (Content Delivery Network): A content delivery network is a global fleet of servers that cache copies of your content close to where people actually are. When someone in Tokyo loads a site whose origin server sits in Virginia, a CDN serves the images, scripts, and often the pages themselves from a nearby edge location instead of routing every byte across the planet. Less distance means lower latency and a faster page.
CDP (Customer Data Platform): A customer data platform (CDP) is software that collects customer data from every source a business uses and stitches it into a single, persistent profile per person. Web behavior, purchase history, app activity, email engagement, support tickets, all of it lands in one place keyed to the same individual.
Churn: Churn is the rate at which customers stop doing business with you over a given period. Count the customers you lost in a month, divide by the customers you started with, and you have your churn rate. It is the quiet counterweight to every new signup.
CI/CD: CI/CD stands for Continuous Integration and Continuous Deployment, or Continuous Delivery. It is a set of practices and tools that automate integrating code changes, running tests, and shipping software to production. The aim is to make each release small, predictable, and low-risk instead of a rare event that everyone dreads.
Circular economy: The circular economy is a model of production and consumption designed to keep materials and products in use for as long as possible, rather than discarding them at the end of a single life. It stands against the linear "take, make, dispose" economy that has dominated since industrialisation, where raw materials become products, products become waste, and the loop never closes.
Cloud-native: Cloud-native describes software built to run in the cloud from the first line, rather than software written for a server and later moved there. It assumes the environment it lives in: elastic, distributed, and able to recover when a piece fails. The cloud isn't where the app happens to sit. It's a property the app is designed around.
CMS (Content Management System): A content management system is software that lets people create, edit, and publish digital content without writing code. The marketing team updates a landing page. An editor schedules an article. None of it requires a developer or a deploy.
Code review: Code review is the step where another engineer reads a change before it gets merged into the codebase. They check whether it does what it claims, whether it fits the rest of the system, and whether anyone will be able to understand it in six months. Then they approve it or ask for changes.
Cohort analysis: Cohort analysis is a technique that groups people by a shared starting event and then follows each group over time. The most common cohort is the month someone signed up. Everyone who joined in January is one cohort, February another, and you watch how each behaves in the weeks and months after.
Color contrast: Color contrast is the difference in luminance between two colours, most often text and the background behind it. It is measured as a ratio, from 1:1 for two identical colours up to 21:1 for pure black on pure white. The higher the ratio, the easier text is to read, especially for people with low vision, colour blindness, or anyone squinting at a screen in bright sunlight.
Component library: A component library is a collection of reusable interface pieces a team builds from. Buttons, inputs, cards, modals, navigation bars. Each one is built once, tested once, and reused everywhere, so a product stays consistent and new screens get assembled instead of redrawn. It usually exists as both coded components for developers and matching design components for designers.
Computer vision: Computer vision is the field of AI that lets machines interpret images and video. Where a human glances at a photo and instantly sees a dog, a road sign, or a defect on a part, a computer sees a grid of pixel values. Computer vision is the set of techniques that turn those raw pixels into something meaningful: a label, a location, a count, a decision.
Conversion rate: Conversion rate is the percentage of people who take a desired action out of everyone who had the chance. Divide conversions by total visitors and multiply by a hundred. If 1,000 people land on a page and 30 buy, the conversion rate is 3%.
Core Web Vitals: Core Web Vitals are Google's three metrics for how a page actually feels to use. Largest Contentful Paint (LCP) measures how long the main content takes to appear. Interaction to Next Paint (INP) measures how quickly the page responds when someone taps or clicks. Cumulative Layout Shift (CLS) measures how much the layout jumps around while loading. Together they put a number on loading speed, responsiveness, and visual stability.
Corporate Social Responsibility (CSR): Corporate social responsibility is a company's self-directed commitment to account for its impact on society and the environment, beyond what the law requires and beyond pure profit. It covers everything from how a business treats its workers and suppliers to its environmental footprint, its community involvement, and its philanthropy.
CRM: CRM stands for customer relationship management. The term covers both a discipline and the software that supports it. As software, a CRM is the system of record for every interaction a company has with its customers and prospects, from the first inbound email to the fifth renewal.
CRUD: CRUD stands for Create, Read, Update, Delete: the four basic operations you can perform on stored data. Add a record, retrieve it, change it, remove it. Nearly every application that keeps data is, at its foundation, doing CRUD. A contacts app creates contacts, reads them into a list, updates a phone number, and deletes the ones you no longer need.
CSS: CSS, Cascading Style Sheets, is the language that controls how a web page looks. HTML defines the structure and content; CSS decides the layout, color, typography, spacing, and how all of it responds to different screen sizes. Without it, every web page would be black text on a white background, stacked top to bottom.
Custom AI Search Engine: A custom AI search engine finds answers based on meaning rather than exact keyword matches. Traditional search looks for the words you typed. AI search understands what you meant, even when your phrasing and the source content share no words at all.
Customer lifetime value (CLV): Customer lifetime value estimates the total profit a customer generates across the whole time they stay with a business, not just on their first purchase. It reframes a customer from a one-off transaction into a relationship with a measurable worth. A subscriber who pays 30 a month for three years is worth far more than that first month suggests, and CLV is how you put a number on it.
Cypress: Cypress is a JavaScript framework for end-to-end testing of web applications. It drives a real browser the way a user would, clicking buttons, filling forms, navigating pages, and asserting that the app behaves as expected. Tests are written in JavaScript or TypeScript and run inside the browser alongside the app, which is what gives Cypress its standout feature: you watch the test execute step by step and can inspect the exact state at any point when something fails.

D

Daily Standup: The daily standup, also called the daily Scrum, is a short meeting held every working day, usually capped at 15 minutes. It is a core ceremony in Scrum and has spread across most Agile teams. The job is to sync everyone, surface blockers early, and keep the team pointed at the sprint goal. It is a team conversation about moving forward together, not a status report read out to a manager.
Dark Mode: Dark mode is a color scheme that swaps light backgrounds for dark ones, with light text on top. Most operating systems, browsers, and apps now offer it, often tied to a system setting that flips at sunset or on a schedule.
Dashboard: A dashboard is a single screen that pulls together the metrics a person needs to do their job, updated from live or near-live data. The name borrows from a car. One glance tells you speed, fuel, and warnings without digging through the engine.
Data ethics: Data ethics is the study of what an organisation should do with data, as distinct from what it is legally allowed to do. Compliance answers the second question. Regulations like GDPR set the floor: get consent, secure the data, let people delete it. Data ethics starts where that floor ends and asks the harder questions about fairness, consent that people actually understand, and harm that no law happens to name yet.
Data governance: Data governance is the framework of rules, roles, and processes that decides how an organization handles its data. Who owns a dataset, who can access it, what a term officially means, how long records are kept, how quality gets checked. It is the difference between data as an asset and data as a liability.
Data lake: A data lake is a store that holds raw data in its original form, at almost any scale, without forcing a structure on it first. Structured tables, JSON logs, images, sensor readings, and clickstream events can all sit in the same lake. You decide how to shape the data when you read it, not when you write it. That flexibility is the whole point.
Data model: A data model is the structure that defines how data is organized, how pieces relate to each other, and what rules they follow. It's the blueprint a database or analytics system is built from. Before a single table exists, the model decides what an "order" is, how it connects to a "customer," and which fields are required.
Data pipeline: A data pipeline is the path data takes from where it is created to where it gets used. It pulls data from sources, moves it through any cleaning or reshaping it needs, and delivers it to a destination like a warehouse, a dashboard, or a machine learning model. Think of it as the wiring between systems that would otherwise never share anything.
Data visualization: Data visualization is the practice of turning numbers into visual form so people can understand them quickly. The human eye reads a trend line in a second and a spreadsheet column in a minute, if at all. Charts, maps, and graphs translate scale and pattern into something the brain processes without effort.
Data warehouse: A data warehouse is a central store of structured data, organized and optimized for analysis. It pulls together data from many systems, sales, support, finance, marketing, into one consistent place where questions can be answered fast. Unlike the databases that run an application, a warehouse is built for reading and aggregating large amounts of historical data, not for handling thousands of small transactions per second.
dbt (data build tool): dbt is a tool for transforming data inside a warehouse. Raw tables go in, clean and modeled tables come out, and the logic in between is written as SQL select statements that dbt turns into the tables and views your analysts and dashboards rely on. It handles the T in ELT, the transform step, after data has already been loaded.
Design system: A design system is the shared set of rules, components, and patterns that define how a product looks and behaves. It connects design decisions to working code, so a button drawn in Figma matches the button that ships. One source of truth, used by designers and developers alike.
Design tokens: Design tokens are named values that store visual decisions. Instead of writing a hex code like #1A73E8 in fifty places, you define color-primary once and reference it everywhere. Colors, spacing, font sizes, border radii, shadows, animation timings. Each becomes a small, reusable variable that both designers and developers point to.
DevOps: DevOps is a way of working that brings development and operations into one loop instead of two teams throwing work over a wall. The people who write the software also share responsibility for running it. That single change reshapes how releases happen.
Digital divide: The digital divide is the gap between people who have meaningful access to digital technology and those who do not. It runs along lines of income, geography, age, and education, and it exists between countries as much as within them. A village with no broadband and a pensioner in a connected city who has never been taught to use a smartphone are both on the wrong side of it, for different reasons.
Digital inclusion: Digital inclusion is the work of making sure everyone can access, afford, and actually use digital technology. It spans three things that have to hold together: connectivity, so people can get online; devices and affordability, so they have something to get online with; and skills and design, so the experience makes sense once they arrive.
Digital sustainability: Digital sustainability is the practice of building and running technology in a way that limits its environmental cost over the full life of a product. It covers the energy a system draws, the hardware it depends on, the data it moves and stores, and how long the thing lasts before it has to be rebuilt. The web feels weightless. It isn't. Every page load, query, and stored file runs on physical infrastructure that burns power.
Disaster recovery: Disaster recovery is the plan and the machinery for getting systems back after something goes badly wrong. A region outage, a corrupted database, a deploy that takes production down, a ransomware hit. It's the answer to one question asked in advance: when this breaks, how do we get it running again, and how much do we lose along the way?
Diversity: Diversity is the presence of difference within a group. Gender, ethnicity, age, nationality, sexual orientation, disability, socioeconomic background, education, and ways of thinking all count. In an organisation, diversity is a question of composition. Who is in the room. Whose voices get heard. Whose perspective shapes the decision that ships.
Diversity, Equity & Inclusion (DEI): Diversity, equity, and inclusion are three connected ideas that often get collapsed into one acronym, which hides how different they are. Diversity is about who is present: the range of backgrounds, identities, and lived experiences in a group. Equity is about fairness: giving people what they each need to compete on level terms, which isn't the same as giving everyone the identical thing. Inclusion is about belonging: whether the people in the room can actually speak, contribute, and shape decisions once they're there.
DNS: DNS, the Domain Name System, translates the names people type into the numbers computers use. You enter a domain like a website address; DNS finds the IP address of the server that answers for it. People remember names. Machines route by numbers. DNS is the layer that connects the two.
Docker: Docker is an open-source platform for developing, shipping, and running applications inside containers. A container bundles an application with its dependencies, libraries, and configuration, so the same image runs the same way on a laptop, a test server, and production.

E

E-commerce: E-commerce is the buying and selling of goods and services online. The term covers the whole chain, not just the moment of payment: the storefront where people browse, the cart, the checkout, the payment processing, and everything that happens after the order to actually get the product to the customer.
Edge case: An edge case is a situation at the boundary of what a system expects. The empty list. The maximum length. The zero. The negative number where only positives were planned for. Software usually handles the middle of its range fine. It breaks at the extremes, and the extremes are exactly where edge cases live.
Edge computing: Edge computing moves processing close to where data is created, instead of sending everything to a central data center and waiting for the answer to come back. The "edge" is the boundary of the network: a sensor, a phone, a local server, a CDN node near the user. Work happens there.
Embeddings: An embedding is a way of representing data as a vector, a list of numbers, so that similar things end up with similar numbers. A model trained on huge amounts of text learns to place words, sentences, or documents as points in a high-dimensional space where distance reflects meaning.
End-to-end testing: End-to-end testing checks that a complete workflow works the way a real user would experience it, across the whole system. A test drives the actual interface, hits the real API, talks to the database, and confirms the result, the same chain a person would trigger. It answers a question unit tests cannot: do all these parts, wired together, actually do the job?
Equity: Equity is the principle of giving people what they each need to reach a fair outcome, accounting for the fact that they don't all start from the same place. It's often confused with equality, and the difference is the whole point. Equality hands everyone the identical resource. Equity recognises that identical treatment can preserve an unfair gap, and adjusts what each person gets so the result is fair, not just the input.
ESG (Environmental, Social, Governance): ESG stands for Environmental, Social, and Governance, three categories used to assess how a company manages risks and responsibilities beyond its financial statements. Environmental covers things like emissions, energy use, and waste. Social covers labour practices, diversity, and community impact. Governance covers board structure, executive pay, transparency, and how decisions get made and audited.
Ethical AI: Ethical AI is the practice of building and deploying artificial intelligence in ways that are fair, transparent, accountable, and respectful of the people affected by it. It rests on a handful of principles that recur across most serious frameworks: fairness, so a system does not encode bias against groups of people; transparency, so its decisions can be explained; accountability, so a human remains answerable for what it does; and privacy, so it does not quietly exploit the data it runs on.
ETL/ELT: ETL and ELT are two ways of getting data out of source systems and into a place where it can be analyzed. Both move data through three steps: extract it from a source, transform it into a usable shape, and load it into a destination. The difference is the order.
Event tracking: Event tracking is the practice of recording specific actions people take in a website or app. A page view is the baseline. Events are everything else: a button click, a video play, a form submission, an add-to-cart, a scroll past a certain point. Each event captures what happened and, through parameters, the detail that makes it useful.
Event-driven architecture: Event-driven architecture is a way of building systems where components communicate by producing and reacting to events rather than calling each other directly. A service does something, announces that it happened, and moves on. Other services listen for that announcement and act on it. The producer never knows or cares who is listening, which keeps the parts loosely coupled.
Exploratory testing: Exploratory testing is hands-on, investigative testing where the tester designs and runs test cases in the moment, learning from each result and deciding what to try next. There's no pre-written script. The tester uses knowledge of the product, the users, and how software tends to break, then follows the trail. It's structured curiosity applied to finding the bugs nobody anticipated.
Express.js: Express.js is a minimal web framework for Node.js. It handles the parts of building a server that every application needs: routing requests to the right handler, parsing incoming data, and running a chain of functions called middleware on the way in and out. It does very little on its own, and that is the point. You assemble the rest from packages you choose.

F

Feature flag: A feature flag, also called a feature toggle, is a way to switch functionality on or off in a running application without deploying new code. The feature lives in the codebase, wrapped in a conditional check against a flag value. That switch decides whether users see it. The point is to separate deploying code from releasing a feature, two acts that traditionally happened at the same moment.
Figma: Figma is a browser-based design tool for building user interfaces, prototypes, and design systems. It runs entirely in the browser, which means designers, developers, and stakeholders can open the same file at once, see each other's cursors, and comment directly on the work. Founded in 2012, it has become one of the most widely adopted tools in product and UX design.
Firebase: Firebase is a backend platform from Google that gives apps the services they would otherwise have to build and host themselves. Authentication, two NoSQL databases (Realtime Database and Cloud Firestore), file storage, hosting, serverless functions, push notifications, and analytics all sit behind one SDK. You write client code, and Firebase handles the server side.
Framer Motion: Framer Motion is an animation library for React. It lets you describe how elements move, fade, and respond to interaction using a declarative API, so you write what an animation should look like rather than manually stepping through frames. A single motion.div with an animate prop replaces a stack of CSS keyframes and JavaScript timing code.
Framework: A framework is a pre-built structure that provides the foundation, conventions, and tools for building a particular kind of application. Instead of starting from an empty file, developers build on top of it, writing the application-specific logic while the framework handles the repetitive infrastructure every project of that type needs.
Full-stack: Full-stack means working across the entire technical stack of an application, both the front end people see and the back end they do not. The front end is the interface in the browser. The back end is the server, the database, and the logic behind it. A full-stack developer or team works on all of it rather than one slice.
Functional testing: Functional testing checks that a feature does what the requirements say it should. You give it an input, you check the output against the expected result. Does the discount code knock 10% off the total? Does the search box return matching products? Does a wrong password get rejected? It treats the software as a black box. What happens inside the code doesn't matter, only that the behavior is correct.
Funnel analysis: Funnel analysis measures how people move through a defined sequence of steps and where they fall out along the way. A funnel is any path with a clear start and goal: view a product, add to cart, start checkout, pay. By counting how many users reach each step, the analysis shows exactly where the journey breaks.

G

GA4 (Google Analytics 4): GA4 is Google's current analytics platform, the replacement for the older Universal Analytics that Google shut down in 2023. It measures how people use a website or app, where they came from, what they did, and whether they converted. The headline change is the data model. GA4 records everything as events rather than the sessions and pageviews that defined the old version.
Gatsby: Gatsby is a static site generator built on React. It pulls content from many sources, a CMS, Markdown files, an API, a database, into a single GraphQL data layer, then builds fast, pre-rendered pages you can host almost anywhere. Because the pages are generated at build time, they load quickly and behave well for SEO out of the box.
GDPR: The General Data Protection Regulation is the EU law that governs how organisations collect, store, and use the personal data of people in the European Union. It applies wherever those people are, so a company in California handling data from customers in Berlin still falls under it. Personal data means anything that identifies a person, directly or not. A name, an email, an IP address, a cookie ID.
Gender equity: Gender equity is the principle of fairness in how people of all genders are treated, recognised, and given access to opportunities. It accepts that real fairness sometimes means giving different support to different people in order to correct imbalances that already exist.
Generative AI: Generative AI is a class of model that produces new content. Text, images, audio, code. It learns statistical patterns from a large body of training data, then generates outputs that follow those patterns when you give it a prompt.
Git: Git is a distributed version control system created by Linus Torvalds in 2005. It tracks changes to files over time and lets many people work on the same codebase at once without overwriting each other's work. Distributed means every contributor holds a full copy of the project history, not just a link to a central server.
GitHub Copilot: GitHub Copilot is an AI coding assistant built by GitHub and OpenAI. It lives inside the editor and suggests code as you type, completing lines, drafting whole functions from a comment, and answering questions about a codebase through chat. Under the hood it runs on large language models trained on public code and natural language. Launched in 2021, it was the first AI pair programmer to reach wide adoption and helped kick off the wave of tools that followed.
Go: Go, also called Golang, is a programming language created at Google in 2009. It was designed to make backend services fast to build, fast to run, and easy to read months after anyone wrote them. It compiles to a single binary, starts instantly, and ships without a heavy runtime.
Google Cloud (GCP): Google Cloud Platform, usually shortened to GCP, is Google's public cloud. It runs on the same infrastructure that powers Search, Gmail, and YouTube, and it offers the full range of cloud services: compute, storage, databases, networking, and a deep bench of data and machine learning tools.
Google Lighthouse: Google Lighthouse is an open-source tool that audits a web page and reports on five areas: performance, accessibility, best practices, SEO, and progressive web app readiness. It loads the page in a controlled environment, measures dozens of signals, and returns a score from 0 to 100 for each category alongside specific things to fix.
Google Tag Manager: Google Tag Manager (GTM) is a tag management system. It sits between your website and the marketing and analytics tools that need to read what happens on it. Instead of a developer hard-coding every tracking snippet into the source, you manage those snippets from a web interface and GTM injects them at runtime.
GraphQL: GraphQL is a query language for APIs and a runtime for executing those queries, developed by Meta and open-sourced in 2015. It offers an alternative to REST by letting clients ask for exactly the data they need, no more and no less.
GraphQL vs REST: GraphQL and REST are two approaches to building an API, the layer through which a frontend asks a backend for data. REST organizes everything around resources, each with its own URL. You fetch a user from one endpoint, their orders from another, each order's items from a third. GraphQL exposes a single endpoint and a schema, and the client sends a query describing exactly the data it wants, getting back that shape and nothing more.
Green software: Green software is software engineered to produce fewer carbon emissions while doing its job. The premise is simple. Code runs on hardware, hardware draws electricity, and electricity carries a carbon cost that depends on where and when it's generated. Greener software either does the same work with less compute, or schedules that work for moments when the grid is cleaner. The discipline has a name now, sometimes called green software engineering, with measurement standards behind it.
Greenwashing: Greenwashing is marketing that makes a product, company, or initiative sound more environmentally sound than it actually is. The label outruns the substance. It ranges from outright false claims to the subtler kind: vague language, cherry-picked numbers, a forest of leaf imagery, and pledges set so far in the future that nobody will check. The point is to capture the reputation of being green without doing the harder work of being it.
GSAP: GSAP, the GreenSock Animation Platform, is a JavaScript library for animating anything on a web page. It moves DOM elements, SVG, canvas, and CSS properties with a timeline-based API that gives precise control over sequencing, timing, and easing. It works with any framework or none, which sets it apart from React-bound libraries.

H

Headless CMS: A headless CMS is a content management system that stores and organizes content but does not control how it looks. It serves everything through an API, leaving the presentation layer, the "head," entirely up to you. A traditional CMS like WordPress bundles the content and the website together. A headless one hands you raw content and lets your frontend decide what to do with it.
Heatmap: A heatmap is a visual layer over a page that uses color to show where users do things. Warm colors mark high activity, cool colors mark low. Click maps show where people tap, scroll maps show how far down they get, and move maps track where the cursor wanders. Aggregated across many sessions, the result is a quick read on what draws attention and what gets ignored.
Hotfix: A hotfix is an urgent patch applied directly to a production system to resolve a critical bug or security vulnerability, without waiting for the next scheduled release. Regular updates move through the full development and testing pipeline. A hotfix skips ahead, because something is broken right now and users are feeling it.
HTML: HTML, short for HyperText Markup Language, is the standard language for structuring content on the web. Every page is an HTML document at its foundation: a hierarchy of elements that define headings, paragraphs, links, images, forms, and the rest of a page's building blocks. It is the skeleton of the web, the structure that CSS styles and JavaScript brings to life.

I

IaaS: IaaS stands for Infrastructure as a Service. It's the raw building blocks of computing rented on demand: virtual machines, storage, networks, load balancers. You spin up what you need, pay for what you use, and shut it down when you're done. No data center, no hardware procurement, no waiting on a rack.
Impact measurement: Impact measurement is the practice of assessing the social and environmental change an organisation actually produces, using evidence rather than assertion. It is what turns a claim like "we help communities" into a defensible number, and it is the discipline that separates real impact work from storytelling.
Inclusion: Inclusion is the active, intentional effort to create an environment where every person feels genuinely welcomed, respected, and able to contribute fully, regardless of background, identity, or perspective. It is the complement to diversity. Diversity asks who is in the room. Inclusion asks whether they belong there.
Inclusive design: Inclusive design is an approach to creating products, services, and environments that work for the widest possible range of people, regardless of age, ability, language, culture, gender, or context. It starts from a simple, uncomfortable question: who might this design exclude, and what would it look like if we designed for them from the beginning instead of patching it in later?
Information architecture: Information architecture is how a product organizes, labels, and connects its content so people can find what they need. It is the structure underneath the interface: which things belong together, what they are called, and how someone moves between them. When a site feels intuitive, good IA is usually the reason. When people get lost, IA is usually the cause.
Infrastructure as Code (IaC): Infrastructure as Code means defining your servers, networks, databases, and cloud resources in files instead of clicking through a console. The files describe what the infrastructure should look like, and a tool makes reality match. Tools like Terraform, Pulumi, and CloudFormation do this for AWS, Google Cloud, and the rest.
Integration testing: Integration testing checks that the separate parts of a system work together. Each piece might pass its own tests in isolation. Integration testing asks the next question. Do they behave correctly once they're connected, calling each other, passing data back and forth?
Internet of Things (IoT): The Internet of Things is the network of physical objects that connect to the internet to send and receive data. A sensor, a thermostat, a factory machine, a parking meter, each carries enough computing and connectivity to report what it senses and act on what it is told. The "thing" is no longer just an object. It is a node in a system.
iOS: iOS is Apple's operating system for iPhone and iPad. It runs the apps, manages the hardware, and defines what a touch interface is allowed to do on an Apple device. Every app in the App Store either targets it directly or runs on top of it.

J

JavaScript: JavaScript is a high-level, interpreted programming language created in 1995 to add interactivity to web pages. It started small, mostly validating forms, and grew into one of the most widely used languages in the world, now running in browsers, on servers, on mobile devices, and inside desktop apps.
Jest: Jest is a testing framework for JavaScript and TypeScript. Built at Meta, it became the default way to test React and Node code. It runs your tests, checks the results against what you expected, and tells you exactly what broke.
Jobs to be done (JTBD): Jobs to be done (JTBD) is a way of thinking about products that starts with the progress a person is trying to make, not the product itself. The core idea is that people don't buy products, they "hire" them to get a job done. A job is the underlying motivation that stays stable even as the solutions around it change. The job statement format captures it: "When [situation], I want to [motivation], so I can [expected outcome]."
JSON: JSON, short for JavaScript Object Notation, is a lightweight, text-based format for storing and exchanging structured data. It is readable by humans, easy for machines to parse, and tied to no single language, which is why it became the default way data moves across the web.
JWT (JSON Web Token): A JSON Web Token is a compact, signed token that carries a small set of claims, typically who the user is and what they are allowed to do. It has three parts: a header, a payload of claims, and a signature. The server signs it with a secret or private key, hands it to the client after login, and the client sends it back with each request. The server verifies the signature and trusts the contents without looking anything up.

K

Kanban: Kanban is a visual workflow management method for moving work through a system and improving how it flows. It started in the Toyota manufacturing system in the 1940s, where the name (Japanese for signboard or visual card) described physical cards that signaled when to produce more. In the 2000s it was adapted for knowledge work and software development.
Kotlin for Android: Kotlin is a modern programming language that runs on the Java Virtual Machine. In 2019 Google made it the preferred language for Android, and it has been the default for new native Android apps since. It interoperates fully with Java, so old and new code live side by side.
KPI (Key Performance Indicator): A KPI, or key performance indicator, is a measurable value that shows how well something is moving toward a goal. The word that matters is "key." Anything can be measured. A KPI is the small set of numbers a team agrees actually reflects success, the ones worth watching every week.
Kubernetes: Kubernetes is a system for running containers across a cluster of machines. You tell it the state you want, say five copies of this service, always healthy, reachable at this address, and it works to keep reality matching that description. If a container crashes, it restarts one. If a machine dies, it reschedules the work elsewhere. If traffic climbs, it can add copies.

L

Lazy loading: Lazy loading is the practice of delaying the load of a resource until the moment it is actually needed. Instead of pulling every image, script, and component when the page first opens, the browser fetches the parts a user can see and holds back the rest. The content further down the page loads as they scroll toward it. The initial payload shrinks, and the page becomes usable faster.
Lead scoring: Lead scoring is the practice of assigning each prospect a number that estimates how likely they are to become a customer. The score lets a sales team spend its time on the leads most worth chasing instead of working a list top to bottom.
Living wage: A living wage is the income a person needs to cover the real cost of a decent life in the place they live. Housing, food, transport, healthcare, and enough left over to absorb a bad month. It is calculated from local data, so the number for London looks nothing like the number for a small town two hours away.
LLM (Large Language Model): A large language model is an AI model trained on enormous amounts of text to predict the next word in a sequence. From that single, simple task it learns enough about language to answer questions, summarize documents, write code, and hold a conversation. Models like GPT, Claude, and Gemini are LLMs. They are a kind of neural network, specifically a transformer, scaled up to billions of parameters.
Load testing: Load testing measures how a system behaves under the traffic it's expected to handle. You simulate a realistic number of concurrent users, push that volume through the application, and watch what happens to response times, throughput, and error rates. The goal is to confirm the system stays fast and stable at the load it will actually see in production, and to find the point where performance starts to degrade.

M

Machine learning: Machine learning is software that learns patterns from data rather than following rules a programmer wrote by hand. Instead of telling a system every condition for spotting fraud, you show it thousands of past transactions labeled fraud or not, and it works out the signals that separate the two. The output is a model, which then makes predictions on new data it has never seen.
Marketing automation: Marketing automation is software that runs marketing actions on rules and triggers instead of someone pressing send. A behavior happens, a condition is met, and the system responds, no human in the loop for each individual.
Message queue: A message queue is a buffer that sits between two parts of a system so they do not have to talk to each other at the same moment. One service puts a message in the queue, another service takes it out and processes it whenever it is ready. The sender does not wait for the work to finish. It hands off the message and carries on.
Meteor: Meteor is a full-stack JavaScript framework for building web and mobile apps. One language runs front to back, client to server to database. It first landed in 2012 as one of the earliest frameworks to make real-time data feel effortless.
MFA (Multi-Factor Authentication): Multi-factor authentication requires more than one proof of identity before granting access. A password alone is a single factor, and passwords get phished, reused, and leaked. MFA asks for a second proof of a different kind, so a stolen password is no longer enough on its own. Even if an attacker has the password, they still cannot get in.
Microinteraction: A microinteraction is a small, contained moment in an interface that does one job. The toggle that slides and changes color. The pull-to-refresh that spins. The subtle shake when a password is wrong. Each one handles a single task: communicate status, confirm an action, prevent a mistake, or make a wait feel shorter.
Microservices: Microservices are an architectural style where an application is split into small, independent services, each owning one capability and talking to the others over the network, usually through APIs. Payments is one service. Search is another. Notifications another. Each can be built, deployed, scaled, and even written in a different language by a different team, without touching the rest.
Middleware: Middleware is code that sits in the path between an incoming request and the logic that finally answers it. Each piece does one job, then passes the request along: check the auth token, log the call, parse the body, set CORS headers, catch errors. By the time the request reaches the actual handler, the cross-cutting concerns are already taken care of.
Mobile-First Development: Mobile-first development is a design and engineering approach that starts with the smallest screen and works outward. You build the core experience for a phone first, then progressively add layout, structure, and features as the viewport grows. The opposite habit, designing for desktop and shrinking down, almost always leaves mobile feeling like an afterthought.
Mocha: Mocha is a testing framework for JavaScript, built mainly for Node.js. It runs your tests and reports the results, and it leaves the rest of the choices to you. Around since 2011, it is one of the oldest and most established test runners in the ecosystem.
Mocking: Mocking replaces a real dependency with a fake one so a test can run in isolation. When the code you're checking calls a payment provider, a database, or a third-party API, you don't want the test to actually charge a card or depend on a server being up. A mock stands in for that dependency, returns the response you tell it to, and lets you verify the code in question without dragging the whole world into the test.
MongoDB: MongoDB is a NoSQL database that stores data as documents instead of rows in tables. Each document is a JSON-like record, and related records group into collections. There is no rigid schema enforced up front, so the shape of the data can change as a product changes.
Monolith: A monolith is an application built and deployed as a single unit. The user interface, the business logic, and the data access all live in one codebase, compile together, and ship together. When you deploy, you deploy the whole thing. For most of software history this was simply how applications were built, and for a great many projects it is still the right call.
Monorepo: A monorepo is a single version-controlled repository that holds many projects: multiple apps, shared libraries, infrastructure code, all in one place with one history. It is the opposite of a polyrepo setup, where each project lives in its own repository with its own versioning and release cycle.
Multi-cloud: Multi-cloud means running your systems across more than one cloud provider. Some workloads on AWS, others on Google Cloud or Azure, chosen deliberately rather than by accident. The aim is usually to avoid depending on a single vendor, to use the best service for each job, or to meet data rules that require certain workloads in certain places.
MVP: MVP stands for Minimum Viable Product: the earliest version of a product with just enough to be usable by real users and to generate meaningful feedback. The concept was popularized by Eric Ries in The Lean Startup, and the idea behind it is straightforward. Test your assumptions about what users want as early and as cheaply as you can, before pouring time and money into building the wrong thing.
MySQL: MySQL is an open-source relational database management system. It stores data in tables with defined columns and relationships, and you query it with SQL. It has run a large share of the web for over two decades, from small WordPress sites to platforms serving millions of users.

N

Neo4j: Neo4j is a graph database. Instead of tables and rows, it stores data as nodes and the relationships between them, treating those connections as first-class citizens you can query directly. You write queries in Cypher, a language designed to read almost like a sentence describing the pattern you want to find.
Net zero: Net zero is the point where the greenhouse gases an organisation adds to the atmosphere are balanced by an equal amount removed. The order matters. Real net zero means cutting emissions as deeply as possible first, then dealing with the small residual that can't yet be eliminated. Removal, not just offsetting, closes the gap.
Neural network: A neural network is a type of machine learning model loosely inspired by how neurons connect in the brain. It is built from layers of simple units, each taking in numbers, weighting them, and passing a result to the next layer. By adjusting those weights against millions of examples, the network learns to map an input, like an image or a sentence, to an output, like a label or a prediction.
Neurodiversity: Neurodiversity is the idea that variation in how human brains work is natural, not a defect to be corrected. It covers conditions like autism, ADHD, dyslexia, and dyspraxia, and it frames them as differences in processing rather than disorders waiting for a cure. Roughly one in seven people is thought to be neurodivergent in some way.
Next.js: Next.js is an open-source web framework built on top of React and maintained by Vercel. It extends React with built-in solutions for routing, server-side rendering, static site generation, image optimization, and API routes, most of it configured out of the box.
NLP (Natural Language Processing): Natural language processing is the field of AI focused on getting computers to understand and produce human language. Language is messy, full of ambiguity, slang, and context, which makes it far harder for a machine than structured numbers. NLP is the set of techniques that bridge that gap, from parsing a sentence's grammar to working out what a customer review actually feels about a product.
Node.js: Node.js is a runtime that runs JavaScript outside the browser, on the server. Before it existed, JavaScript lived only on the front end. Node moved it to the backend, so a team can build both halves of an application in one language.
NoSQL: NoSQL is a family of databases that store data without the rigid table structure of traditional relational systems. The name means "not only SQL." Where a relational database forces every row into a fixed schema, NoSQL lets the shape of the data flex, which suits applications where requirements change fast or data does not fit neatly into rows and columns.

O

OAuth: OAuth is a protocol for delegated authorization. It lets one application access a slice of a user's data on another service without ever handling that user's password. Instead of typing your Google password into a third-party app, you are redirected to Google, you approve a specific set of permissions, and the app receives an access token scoped to exactly what you allowed. The password never leaves Google.
OLAP vs OLTP: OLTP and OLAP describe two kinds of database workload. Online transaction processing (OLTP) runs the day-to-day operations of a business. It handles many small, fast writes and reads, one record at a time. Online analytical processing (OLAP) answers questions across large volumes of historical data. It reads wide, scans deep, and aggregates.
Open source: Open source is software whose source code anyone can read, use, modify, and share, under a license that grants those rights formally. The license is the load-bearing part. "You can see the code" is not open source on its own. What makes it open is the legal permission to do something with it. Licenses range from permissive ones like MIT, which let you do almost anything, to copyleft ones like the GPL, which require that what you build on top stays open too.
OpenAPI (Swagger): OpenAPI is a standard, machine-readable way to describe a REST API. One file, written in YAML or JSON, lists every endpoint, the parameters they take, the shape of each request and response, the auth they require, and the errors they can return. Swagger was the original name. When the spec was donated to the Linux Foundation it became OpenAPI, and the Swagger name now refers to the tooling built around it.
ORM (Object-Relational Mapping): Object-relational mapping is a layer that lets you work with a relational database through the objects of your programming language instead of raw SQL. A row in a users table becomes a User object. Reading, creating, and updating records happens through method calls, and the ORM generates the SQL underneath. Database columns map to object fields, relationships map to references between objects.

P

PaaS: PaaS stands for Platform as a Service. It gives developers a place to deploy and run code without touching the machines underneath. The provider handles servers, operating systems, networking, and runtime. You push your application and it runs.
Panda CSS: Panda CSS is a styling engine for modern web apps that generates type-safe CSS at build time. You write styles in your JavaScript or TypeScript using its functions, and Panda compiles them into static CSS files with nothing shipped to the browser at runtime.
Pay equity: Pay equity is the principle that people are paid fairly for work of equal value, regardless of gender, race, or other characteristics that have nothing to do with the job. It's about the structure of pay itself: whether two people doing comparable work, with comparable experience and results, end up in comparable places on the scale. When they don't, and the difference tracks who they are rather than what they do, pay equity is broken.
Penetration testing: Penetration testing is an authorised, simulated attack on a system to find the weaknesses a real attacker would use. A tester takes the role of an adversary and tries to break in, escalate access, and reach data they should never see. The goal is defensive. You find the holes on your own terms, with permission, and fix them before anyone hostile does.
Performance testing: Performance testing is the category of software testing that evaluates how a system behaves under a given workload. Functional testing checks whether a system does the right thing. Performance testing checks whether it does it fast enough, reliably enough, and at the scale you actually need.
PHP: PHP is a server-side scripting language built for the web. It runs on the server, generates HTML, and sends it to the browser. It powers a huge slice of the internet, including WordPress, which alone runs a large share of all websites.
Playwright: Playwright is an open-source framework, built by Microsoft, for automating browsers. It drives Chromium, Firefox, and WebKit through a single API, so one test suite can confirm a site behaves the same in Chrome, Safari, and Firefox. You write a script that clicks, types, and navigates like a user would, then assert that the right things happen. It's a leading tool for end-to-end testing of web apps.
PostgreSQL: PostgreSQL, often called Postgres, is an open-source relational database known for being powerful, standards-compliant, and reliable. Like other relational systems it stores data in tables and uses SQL, with full ACID transactions that keep data consistent even when things go wrong mid-write.
Preact: Preact is a JavaScript library for building user interfaces. It mirrors the React API but ships in roughly 3 kilobytes instead of React's 40-plus. Same component model, same hooks, same JSX. A fraction of the weight on the wire.
Predictive analytics: Predictive analytics uses historical data to estimate what is likely to happen next. Where standard reporting tells you what already occurred, predictive analytics builds models that turn past patterns into forward-looking probabilities: which customers are about to leave, how much stock you'll need next month, which leads are worth chasing. It answers the question "what comes next" rather than "what happened."
Product backlog: The product backlog is the single, ordered list of everything a team might work on. Features, improvements, bug fixes, technical tasks, experiments, compliance work. If it isn't in the backlog, it isn't planned work yet. It's the source of truth for what the product needs and in what order.
Prompt engineering: Prompt engineering is the practice of designing the instructions you give a language model so it produces the output you actually want. The same model can return a vague paragraph or a clean, structured answer depending entirely on how the request is framed.
Prototype: A prototype is a working model of a product that people can interact with before it is fully built. Tap a button and a screen changes. Fill a field and something happens. It turns a static design into an experience you can test, react to, and improve while the cost of change is still low.
Psychological safety: Psychological safety is the shared belief that a team is a safe place to take interpersonal risks. Asking a basic question, admitting a mistake, disagreeing with the most senior person in the room, none of it carries a hidden cost to your standing. The term comes from organisational researcher Amy Edmondson, and it describes a climate, not a personality trait.
Pull request: A pull request is a proposal to merge a set of code changes into a shared branch. The author has done the work on their own branch and now asks the team to review it and pull it in. The name comes from Git, and the concept anchors how most software teams collaborate on GitHub, GitLab, and Bitbucket.
Push Notifications: Push notifications are messages delivered to a device even when the app or site is closed. The user does not have to be looking. The message arrives on the lock screen or in the notification tray, sent from a server rather than pulled by the app.
PWA (Progressive Web App): A Progressive Web App is a website that behaves like an installed application. It runs in the browser but can be added to a home screen, work offline, send push notifications, and load instantly on repeat visits. No app store, no download, no separate codebase for each platform.
Python: Python is a general-purpose programming language built around readable, indentation-driven syntax. It runs everywhere, from quick scripts to large backend systems, and it carries one of the deepest library ecosystems in software. You write less code to do more, which is why it became the default teaching language and the default glue language at the same time.

Q

Quality Assurance (QA): Quality assurance is the set of processes that keep defects out of a product in the first place. It shapes how software gets built: the standards developers follow, the way code is reviewed, the gates a build clears before it deploys. QA is proactive. It works on the process, not the output.
Quality Control (QC): Quality control is the inspection of a finished or near-finished product to find defects and confirm it meets its requirements. It is reactive by design. Where quality assurance prevents problems by improving the process, QC detects the problems that already made it into the build.

R

RAG (Retrieval-Augmented Generation): Retrieval-augmented generation is a pattern that feeds a language model relevant source material before it answers. Instead of relying only on what the model memorized during training, the system first retrieves passages from your own knowledge base, then asks the model to answer using that retrieved context.
Raspberry Pi: A Raspberry Pi is a single-board computer the size of a credit card. A full system on one board: processor, memory, USB, networking, and a row of GPIO pins for wiring up sensors and hardware. It runs a real Linux operating system, so the same languages and tools you use on a server run here too. Cheap enough to buy a dozen and treat them as disposable.
Rate limiting: Rate limiting controls how many requests a client can make to a service in a given window of time. Hit the cap and the server responds with a 429 status, usually with a header telling you when you can try again. It is the mechanism that keeps one client, malicious or just badly behaved, from swamping a system that everyone else depends on.
React: React is an open-source JavaScript library built by Meta for creating user interfaces. It launched in 2013 and became one of the most widely used frontend technologies on the web. When you interact with a modern web app that updates instantly without reloading the page, there's a good chance React is doing the work underneath.
React Native: React Native is a framework for building mobile apps with React. You write components in JavaScript or TypeScript, and the framework renders them as real native UI elements on iOS and Android rather than as web views. One codebase, two platforms, genuinely native widgets on screen.
Recommendation engine: A recommendation engine is a system that predicts what a user is likely to want next and surfaces it. It is the machinery behind the "you might also like" row, the suggested next video, the products that appear at checkout. The engine takes what it knows about a user and their behavior and ranks a catalog of items by how likely each one is to be relevant right now.
Redis: Redis is an in-memory data store. It keeps data in RAM instead of on disk, which is why reads and writes return in microseconds rather than milliseconds. It speaks a simple key-value model but supports rich structures on top: strings, hashes, lists, sets, sorted sets, streams. Less a database in the traditional sense, more a fast layer that sits in front of one.
Regression testing: Regression testing re-runs existing tests after a code change to confirm that nothing which used to work is now broken. The name comes from regression itself: a defect that was fixed coming back, or a working feature breaking for no obvious reason. Every change risks it, whether the change is a bug fix, a new feature, or a refactor.
Remote-first work: Remote-first means an organisation runs as though everyone is distributed by default. Decisions, documentation, and communication are built for people who are not in the same room, and the office becomes one option among several rather than the centre everything orbits.
Responsive design: Responsive design is the practice of building one website that adapts its layout to whatever screen it lands on. The same code reflows from a phone to a tablet to a wide desktop monitor, without separate versions for each. One site, many shapes.
REST API: A REST API (Representational State Transfer Application Programming Interface) is a standard way for two systems to talk to each other over HTTP. It follows a set of architectural principles that make web services predictable, stateless, and easy to work with across different platforms and languages.
Ruby on Rails: Ruby on Rails is a full-stack web framework written in the Ruby language. It gives you the whole backend in one opinionated package: database layer, routing, controllers, templating, background jobs, and a mature set of conventions for how they fit together. Released in 2004, it shaped how a generation of web apps got built.

S

SaaS: SaaS stands for Software as a Service. It's software you reach through a browser, paid for as a subscription, with the provider running everything behind the scenes. No installs, no servers to patch, no version that drifts out of date on one laptop. You log in, it works.
Sass (SCSS): Sass is a preprocessor for CSS. You write stylesheets in a more capable language, and a build step compiles them down to plain CSS the browser understands. SCSS is the most common syntax for it, and it is a superset of CSS, which means any valid CSS file is already valid SCSS. You adopt it without rewriting what you have.
Scrum: Scrum is an Agile framework for managing complex work. It was formalised by Ken Schwaber and Jeff Sutherland in the early 1990s for software projects, and has since spread well beyond them. The idea is to deliver work in short, repeatable cycles instead of one long march toward a distant deadline.
Security testing: Security testing looks for the ways software can be broken on purpose. Where functional testing asks whether a feature works, security testing asks whether someone can abuse it: inject data it shouldn't accept, reach pages they shouldn't see, or pull out information that should stay private. The goal is to find those holes before an attacker does.
Segmentation: Segmentation is the practice of dividing a customer base into groups that share something meaningful. Instead of treating everyone as one undifferentiated audience, you split them by traits, behavior, or value so each group can be understood and addressed on its own terms.
Selenium: Selenium drives a real browser the way a person would. It clicks buttons, fills forms, follows links, and reads what comes back. The point is to run a workflow end to end and confirm the application behaves as it should, without a human repeating the same steps by hand every release.
Serverless: Serverless is a way of running code without managing the servers it runs on. There are still servers. You just stop owning them. The cloud provider handles capacity, scaling, and patching, and you deploy functions that wake up to handle a request and disappear when they are done. AWS Lambda, Cloudflare Workers, and Google Cloud Functions are the common platforms.
Service worker: A service worker is a script the browser runs in the background, separate from the web page, acting as a programmable proxy between the page and the network. Because it sits in that position, it can intercept network requests and decide how to answer them: from the network, from a cache it controls, or some mix of the two. It runs even when the page is closed, which is what makes background behaviour on the web possible at all.
Session recording: Session recording captures a replayable view of how a real person used a product. It logs clicks, scrolls, cursor movement, and navigation, then reconstructs the session so you can watch what happened. Analytics tells you that people drop off on a certain step. A recording shows you why, by letting you see the rage clicks, the hesitation, the field someone filled three times before giving up.
Smoke testing: A smoke test is a quick, shallow set of checks run against a new build to confirm its most critical functions work before deeper testing starts. The name comes from electronics. Power on a new circuit board, watch for smoke, and if nothing catches fire you proceed. Software borrows the idea exactly.
Social impact: Social impact is the effect an organisation, project, or decision has on the wellbeing of people and communities. It spans the deliberate good a company sets out to do and the side effects it creates along the way, intended or not. The term covers things like access to opportunity, health, education, fair work, and inclusion.
SolidJS: SolidJS is a JavaScript library for building user interfaces. It looks a lot like React, with JSX and components, but the engine underneath is completely different. Solid uses fine-grained reactivity and skips the virtual DOM entirely. The result is among the fastest rendering performance of any frontend library.
SPA (Single Page Application): A single page application loads one HTML document, then rewrites the visible content with JavaScript as the user navigates. The browser never does a full page reload. Clicking a link swaps the view, fetches whatever data it needs over an API, and updates the screen in place. The result feels closer to a desktop application than a traditional website.
Spacing and layout: Spacing and layout are how an interface organises elements in space so people can read and use it without effort. Spacing is the gaps: the margins around a block, the padding inside a button, the room between a heading and the text below it. Layout is the larger arrangement, the grid and structure that decide where things sit on the page. Together they shape how an interface feels long before anyone reads a word of it.
Sprint: A sprint is the basic unit of work in Scrum. It's a fixed, time-boxed period, usually one to four weeks, during which a team completes a defined set of backlog items and delivers a potentially shippable product increment. The time box is the whole point. The clock doesn't move, so the scope does.
Sprint Planning: Sprint planning is the meeting that opens every sprint in Scrum. The whole team shows up: Product Owner, Scrum Master, developers. They agree on what to build next and how to approach it. The two outputs are a sprint goal and a sprint backlog, the specific set of items the team commits to finishing by the end of the iteration.
Sprint retrospective: The sprint retrospective is the meeting at the end of a sprint where the team looks at how it worked, not what it built, and decides what to change. It's one of Scrum's most useful events because it turns improvement into a scheduled habit instead of something that only happens after a project goes badly wrong.
Sprint Review: The sprint review is the meeting at the end of a sprint where the team shows stakeholders what it built. The Product Owner, leadership, and anyone with a stake in the product see the working increment and react to it. The point is to inspect what was completed and gather feedback that shapes how the backlog gets prioritised next.
SQL injection: SQL injection is an attack where untrusted input alters the database query a server runs. When an application builds a query by gluing user input directly into a string, an attacker can write input that changes what the query does. Instead of searching for a username, the query might return every row, skip the password check, or drop a table. The attack hits the database and the data behind it, which is what makes it dangerous.
SQL vs NoSQL: SQL and NoSQL are two broad approaches to storing and querying data, each suited to different problems. SQL databases, also called relational databases, organise data into structured tables with predefined schemas and enforce relationships between them. PostgreSQL, MySQL, and SQLite are common examples. They shine at complex queries, transactional operations, and any case where data consistency can't be compromised.
SSG (Static Site Generation): Static site generation builds every page into finished HTML at build time, before anyone visits. When a request comes in, the server hands over a pre-built file. There is no rendering on demand, no database query in the request path, nothing to compute. The page just ships, usually straight from a CDN at the network edge.
SSL/TLS: SSL/TLS is the technology that encrypts data as it travels between a browser and a server. It is what turns http into https and puts the padlock in the address bar. SSL was the original protocol; TLS is its modern successor. The industry still says "SSL" out of habit, but every secure connection today actually uses TLS.
SSR (Server-Side Rendering): Server-side rendering builds the HTML for a page on the server, for each request, and sends it to the browser fully formed. The user sees real content the moment it arrives, before any JavaScript has run. The page then hydrates: the JavaScript attaches and the static markup becomes a live, interactive app.
Stakeholder capitalism: Stakeholder capitalism is the idea that a company exists to serve everyone it affects, including employees, customers, suppliers, communities, and the environment, rather than maximising returns for shareholders alone. It stands directly opposed to shareholder primacy, the doctrine most associated with economist Milton Friedman, which held that a company's only social responsibility is to increase its profits.
Story points: Story points are the unit Agile teams use to estimate the relative effort, complexity, and uncertainty of backlog items. They're deliberately abstract. Instead of "this will take three hours," a story point says how hard a piece of work is compared to other work the team has done, without locking in a duration that nobody can honestly predict yet.
Stress testing: Stress testing pushes a system past the limits it was built for to find out where and how it breaks. You ramp traffic or data far beyond expected peaks, keep going, and watch the failure happen. The point isn't to confirm the system survives. It's to learn what happens when it doesn't, and whether it fails in a way you can recover from.
Style guide: A style guide is the document that defines how a brand or product should look and sound. Colors and their exact values, typography and how to use it, logo rules, imagery, spacing, and often tone of voice. It exists so that everyone touching the brand, inside the company or out, makes the same choices and the work stays coherent.
Sustainability: Sustainability is the capacity to meet the needs of the present without compromising the ability of future generations to meet their own. The idea spans three connected dimensions: environmental, social, and economic. The approaches that hold up address all three at once rather than treating them as separate agendas.
Sustainable Development Goals (SDGs): The Sustainable Development Goals are a set of 17 objectives adopted by all United Nations member states in 2015 as part of the 2030 Agenda. They cover the broad span of human and planetary wellbeing, from ending poverty and hunger to climate action, quality education, gender equality, decent work, and responsible consumption. Each goal breaks down into specific targets and indicators, 169 targets in total, meant to make progress trackable rather than aspirational.
Sustainable web design: Sustainable web design is the practice of building websites that deliver what they need to deliver while drawing as little energy as possible. Every page loaded runs on servers, travels across networks, and renders on a device, and each step burns power. The heavier the page, the more it burns, on every single visit. Design choices that look purely visual turn out to have a real energy cost.
Svelte: Svelte is a UI framework that does its work at build time. Instead of shipping a framework runtime to the browser and reconciling a virtual DOM at runtime, Svelte compiles your components into small, direct JavaScript that updates the DOM itself. The framework largely disappears once the app is built. What reaches the user is lean code, not a library.
Swift for iOS: Swift is the programming language Apple created for building software across its platforms. On iOS, it's the language most native apps are written in. It compiles to machine code, runs fast, and gives developers direct access to the iPhone hardware and the system frameworks that make an app feel native.
SwiftUI: SwiftUI is Apple's framework for building user interfaces. You describe what the screen should look like in a given state, and the framework figures out how to render it and how to update it when that state changes. Write it once in Swift, and the same code adapts across iPhone, iPad, Mac, Apple Watch, and Apple TV.

T

TailwindCSS: TailwindCSS is a CSS framework that styles interfaces with small utility classes instead of custom stylesheets. Want padding, a flex layout, and a blue background? You add classes like p-4, flex, and bg-blue-500 right on the element. The style lives next to the markup, so you rarely jump between files to figure out where a rule comes from.
Tech for good: Tech for good describes technology built with a deliberate social or environmental purpose, where the impact is part of the point rather than a side effect. It covers a wide range: tools that help charities run, platforms that widen access to healthcare or education, systems that measure and cut emissions, products designed to include people the market usually overlooks.
Technical debt: Technical debt is the future cost of a shortcut taken today. You ship something quickly using a quick fix instead of the right design, and later you pay interest on that decision in the form of slower changes, more bugs, and harder onboarding. The metaphor is borrowed from finance, and it holds up well.
TensorFlow.js: TensorFlow.js is a library for running machine learning models in JavaScript. That means a model can run directly in a user's browser or on a Node.js server, no Python and no separate ML backend required. It can train new models, fine-tune existing ones, or simply run predictions from a model trained elsewhere.
Test automation: Test automation is running tests with code instead of a person clicking through the app. You write scripts that exercise the software, assert on the results, and report pass or fail. Once written, they run on demand: on every commit, every night, before every release. The same checks that would take a human an afternoon run in minutes and never get bored or skip a step.
Test case: A test case is a documented set of conditions, inputs, and expected outcomes used to verify that one specific part of a system behaves the way it should. It's the atomic unit of structured testing: the precise scenario a tester runs, by hand or in code, to decide whether a feature passes or fails against a requirement.
Test coverage: Test coverage measures how much of your code gets executed when the test suite runs, usually as a percentage. Line coverage tracks which lines ran. Branch coverage tracks whether both sides of each if/else were taken. Function coverage tracks which functions were called at all. A tool instruments the code, runs the tests, and reports the share of it that the tests actually touched.
Test plan: A test plan is the document that decides what gets tested before anyone starts testing. Scope, approach, schedule, environments, who owns what, and what counts as pass or fail. It turns a vague intent to "check the feature" into a clear agreement the whole team can point to.
Test-driven development (TDD): Test-driven development is a practice where you write the test before the code it checks. The rhythm has a name, red-green-refactor, and it repeats. Write a test for the behaviour you want. It fails, because the code doesn't exist yet. Write the minimum code to make it pass. Then clean up the structure without breaking the test. Round again.
Testing: Software testing is the practice of verifying that code does what it's supposed to: automatically, repeatedly, and without a human clicking through the app after every change. A test suite runs thousands of checks in seconds and catches regressions the moment they appear. It's a core discipline of software engineering, not a final step squeezed in before release.
Theory of change: A theory of change is a structured explanation of how and why a set of activities is expected to lead to a desired long-term outcome. It maps the chain backwards from the goal: this is the change we want, these are the conditions needed to reach it, these are the activities that produce those conditions, and these are the assumptions that have to hold true for the whole thing to work.
Three.js: Three.js is a JavaScript library for rendering 3D graphics in the browser. It sits on top of WebGL, the low-level interface that lets a web page talk to the graphics card. WebGL on its own is verbose and unforgiving. Three.js wraps it in concepts a developer can reason about: scenes, cameras, lights, meshes, materials.
Triple bottom line: The triple bottom line is an accounting framework that judges a company on three measures instead of one: people, planet, and profit. The term was coined by John Elkington in 1994 as a way to argue that financial performance alone is an incomplete picture of whether a business is actually succeeding. Social and environmental results belong on the ledger too.
TypeScript: TypeScript is a programming language built by Microsoft that extends JavaScript with optional static typing. It compiles down to plain JavaScript, so it runs anywhere JavaScript runs: browsers, servers, edge functions, mobile shells. You write code with extra guarantees, and the output is the JavaScript everyone already knows.
Typography: Typography is the practice of arranging type so written language is legible, readable, and clear in its intent. It covers far more than choosing a typeface. Size, weight, line height, line length, letter spacing, and the relationships between all of them decide how easily someone reads a screen and how quickly they understand what matters. Good typography is mostly invisible. You notice bad typography immediately.

U

UI (User Interface): The user interface is the point where a person meets a digital system. It covers everything someone can see, touch, or act on: buttons, menus, forms, typography, icons, layout, visual hierarchy. In a digital product, the UI is the surface through which every feature gets used. If the experience is the journey, the interface is the vehicle the user actually holds.
Unit testing: A unit test is an automated test that checks the smallest testable piece of code on its own. Usually a single function, method, or class. It exercises one thing, one scenario, with nothing else attached: no database, no network, no file system. Anything the unit normally pulls from the outside world gets swapped for a controlled stand-in called a mock or a stub.
Usability: Usability is how easily and effectively people can use a product to do what they came to do. It is measured, not assumed. Can a first-time user complete the task? How long does it take? How many mistakes do they make, and can they recover? A usable product gets out of the way; an unusable one makes people work to overcome it.
User flow: A user flow is the path a person takes through a product to complete a single task. Sign up. Reset a password. Buy a pair of shoes. Each flow lays out the screens, decisions, and actions in the order they happen, so a team can see exactly where someone moves forward and where they get stuck.
User journey: A user journey is the full arc of someone's experience with a product or brand, from the first time they hear about it to long after they have used it. A journey map lays out the stages, the actions at each one, and the thoughts and emotions that go with them. It captures highs and lows across channels and time, not just clicks on a screen.
User persona: A user persona is a profile that stands in for a real group of users. It captures who they are, what they are trying to do, and what gets in their way. A good persona has a goal, a context, and a few frustrations that the product needs to answer. A bad one has a stock photo and a favorite coffee order.
User research: User research is the work of learning what people actually need from a product, based on evidence rather than opinion. It covers interviews, surveys, usability testing, field studies, and analytics. The point is to replace assumptions about users with observations of them, so design decisions rest on something real.
User story: A user story is a short description of a feature told from the perspective of the person who will use it. It answers who wants something, what they want, and why. The common format reads: "As a [type of user], I want [an action], so that [a benefit]." That last clause is the one that matters most, because it forces the team to name the reason behind the work instead of just the mechanic.
UTM parameters: UTM parameters are tags added to the end of a URL that tell your analytics tool where a visitor came from. They're the small text after a question mark in a link, and they turn an anonymous click into a traceable source. UTM stands for Urchin Tracking Module, named after the analytics tool that became Google Analytics.
UX (User Experience): User experience is the overall quality of how a person interacts with a product, service, or system. It covers what someone thinks, feels, and does before, during, and after using it: how easy a task is to finish, how intuitive the navigation feels, how satisfying the result is. UX is the sum of every one of those moments, including the ones that go wrong.

V

Vector database: A vector database stores data as embeddings, which are lists of numbers that capture the meaning of text, images, or other content. Instead of matching exact words, it finds items whose vectors sit close together in that numeric space, which means it can retrieve things that are similar in meaning even when they share no keywords.
Versioning: Versioning is the practice of assigning unique identifiers to the successive states of a software product, file, or dataset. Those identifiers, usually numbers or a mix of numbers and letters, let teams track changes over time, communicate what each update actually does, and roll back to an earlier state when something goes wrong.
Visual regression testing: Visual regression testing catches the changes a functional test never sees. It takes a screenshot of a page or component, stores it as the baseline, then compares every later build against that image pixel by pixel. When something moves, overlaps, or shifts color, the diff flags it. A button that still clicks but now sits half off the screen passes a functional test and fails a visual one.
Vite: Vite is a build tool for modern web projects. It does two jobs. During development it runs a local server that updates the browser the instant you save a file. For production it bundles everything into optimized files ready to deploy. It works with React, Vue, Svelte, and plain JavaScript alike.
Vue.js: Vue.js is a JavaScript framework for building user interfaces and single-page applications. You break the interface into components, each one bundling its template, logic, and styles, and Vue keeps what's on screen in sync with your data automatically. Change the data, and the relevant part of the page updates on its own.

W

WCAG: WCAG stands for the Web Content Accessibility Guidelines, the international standard for making digital products usable by people with disabilities. Published by the W3C, it is the reference most accessibility laws and procurement rules point to, including the European Accessibility Act and Section 508 in the US. When someone says a site needs to be accessible, WCAG is usually the yardstick they mean.
Web Components: Web Components are a set of native browser standards for building reusable custom HTML elements. No framework required. You define an element like <user-card>, give it its own behavior and styling, and use it anywhere HTML runs. Three technologies make it work: Custom Elements for defining the tag, Shadow DOM for encapsulating styles and markup so they do not leak in or out, and HTML templates for reusable chunks of markup.
Web scraping: Web scraping is the automated extraction of data from websites. A program fetches a page, reads its HTML, and pulls out the specific values you want, prices, listings, reviews, contact details, then stores them in a structured form you can actually use. It is what you do when the data you need is published on the web but no API hands it to you cleanly.
WebAssembly (WASM): WebAssembly is a binary instruction format that runs in the browser at close to native speed. Code written in C, C++, Rust, or Go gets compiled to a compact WASM module, and the browser executes it inside the same sandbox that runs JavaScript. The two work side by side. JavaScript handles the DOM and the glue, WASM handles the heavy computation.
Webhook: A webhook lets one system automatically notify another when a specific event happens, by sending an HTTP request to a URL the recipient set up in advance. A traditional API makes the client keep asking "has anything changed yet?", a pattern called polling. A webhook flips that around. The server reaches out the moment something happens. It's the difference between checking your mailbox every hour and having the carrier ring the doorbell when a package lands.
WebSockets: WebSockets are a communication protocol that holds open a persistent, two-way connection between a client and a server over a single TCP connection. HTTP works on a request-and-response model, where the client has to start every exchange and the connection closes after each one. A WebSocket connection stays open, so either side can send data to the other at any moment with very little overhead.
Wireframe: A wireframe is the structural skeleton of a screen. It maps where things go, what content sits where, and how a user moves through a layout, all before anyone picks colors or fonts. Boxes, labels, placeholder text. The point is to settle structure and priority while changes still cost minutes instead of days.

X

XML: XML, short for Extensible Markup Language, is a text-based format for storing and moving structured data. It uses nested tags to describe both the structure and the meaning of data, in a way that a person and a machine can both read. The World Wide Web Consortium published it as a standard in 1998, and through the early 2000s it became the universal format for passing data between systems.
XSS (Cross-Site Scripting): Cross-site scripting is a web vulnerability where an attacker injects malicious code into a page that other people then load in their browser. The browser trusts the page, so it runs the script as if the site wrote it. From there an attacker can steal session cookies, read what a user types, or act as that user. XSS targets the people visiting a site, which is what separates it from a server-side attack.

Y

Z

Zero waste: Zero waste is a philosophy and a set of practices aimed at eliminating what gets sent to landfill, incineration, or the environment by rethinking how resources flow through a system. Instead of managing waste once it exists, zero waste thinking goes after the source. It asks why the waste is created at all, then redesigns products, processes, and systems so materials can be fully reused, recycled, composted, or returned to the production cycle.
Zero-trust security: Zero-trust is a security model that assumes no user, device, or request is trustworthy by default, even inside the network. The older approach guarded the perimeter and trusted everything within it, which fell apart the moment an attacker got past the wall or a laptop got compromised. Zero-trust drops the idea of a safe inside. Every request is verified, every time, regardless of where it comes from.

Ready to work together?

Book a meeting

Aymón holding a Tools magazine in front of their facem

Ari working on a laptop outdoors surrounded by plants

Top-down view of a wooden desk with a keyboard, mouse, and headphones

Hand-drawn illustration of a hand snapping fingers

Nico leaning against a water cooler next to a fire extinguishe

Close-up of an open computer with circuit board and components on a wooden desk

Bernat and Andreu collaborating at a desk with monitors and a laptop

Hand-drawn illustration of an open hand waving