Tech career glossary

Every term career changers need to know

90+ terms across product, agile, data, design, engineering, and business — explained in plain English for people coming from outside tech.

Use Ctrl+F (or Cmd+F on Mac) to search for a specific term.

Product & Strategy

APM (Associate Product Manager): An entry-level product management role, often structured as a rotational programme at companies like Google, Meta, and LinkedIn. APMs work alongside senior PMs to learn how to define problems, write specs, and ship features. (Example: Google's APM programme is one of the most competitive in the industry.)
PRD (Product Requirements Document): A document that describes what a feature needs to do — the problem it solves, who it is for, and what success looks like. Engineers and designers use the PRD to understand what they are building and why. (Example: A PRD for a new checkout flow would define every step, edge case, and acceptance criterion.)
Roadmap: A high-level visual plan that shows what the team will build, when, and why. A roadmap communicates priorities to stakeholders and aligns the whole organisation — it is a strategic document, not a fixed delivery schedule. (Example: A quarterly roadmap might show three major bets across the next 12 weeks.)
OKR (Objectives and Key Results): A goal-setting framework where teams define an ambitious Objective (qualitative direction) and measurable Key Results that confirm progress. OKRs are usually set quarterly and kept public. (Example: Objective — 'Make onboarding effortless'. Key Result — 'Increase Day 1 completion rate from 40% to 65%'.)
KPI (Key Performance Indicator): A measurable value that shows how well a team or product is performing against its goals. A good KPI is specific, tied to a goal, and tracked over time. (Example: Monthly active users, conversion rate, and average revenue per user are common product KPIs.)
North Star Metric: The single metric that best captures the core value a product delivers to customers. It aligns the whole organisation around the same goal — not just revenue, but the outcome that drives revenue. (Example: Spotify's North Star is time spent listening; Airbnb's is nights booked.)
MVP (Minimum Viable Product): The simplest version of a product that still delivers enough value to attract early users and generate real learning. An MVP tests the core hypothesis with the least amount of effort — it is deliberately scoped, not incomplete. (Example: Dropbox's MVP was a demo video before any product was built.)
PLG (Product-Led Growth): A go-to-market strategy where the product itself drives acquisition, retention, and expansion — rather than a traditional sales team. Users sign up, experience value, and then upgrade or invite others. (Example: Slack, Notion, and Figma all grew primarily through PLG.)
PMF (Product-Market Fit): The degree to which a product satisfies a strong market demand. When you have PMF, users love the product, retention is high, and growth feels almost effortless. Before PMF, growth is a grind. (Example: A common test: 'What percentage of your users would be very disappointed if this product disappeared?' — 40%+ suggests PMF.)
GTM (Go-to-Market): The plan for launching a product to market — who you are targeting, how you will reach them, what message you will use, and through which channels. (Example: A GTM plan might specify targeting mid-market B2B companies via content marketing and outbound sales.)
MoSCoW: A prioritisation framework that sorts features into Must have (critical), Should have (important), Could have (nice to have), and Won't have (out of scope). It forces teams to be explicit about what is truly essential. (Example: 'User login' is a Must; 'Dark mode' is a Could.)
RICE: A scoring framework for prioritising features: Reach (how many users?), Impact (how much does it matter?), Confidence (how certain are you?), Effort (how much work?). Higher RICE scores get built first. (Example: A feature reaching 10,000 users with high impact and low effort would score far higher than a niche, expensive improvement.)
A/B Test: An experiment where two versions of something — a page, a button, an email subject line — are shown to different groups of users to see which performs better. The data decides the winner. (Example: Testing a blue vs. green 'Sign Up' button to see which drives more clicks.)
Feature Flag: A toggle in software that turns a feature on or off without deploying new code. Teams use flags to release features gradually or to run experiments safely. (Example: Rolling out a new checkout flow to 5% of users before enabling it for everyone.)
Beta Test: An early release of a product to a limited audience before the public launch. Beta users test real features and report bugs so the team can fix problems before everyone gets access. (Example: Running a private beta with 500 power users before a public launch.)

Agile & Delivery

Sprint: A fixed-length work cycle in Agile, typically one or two weeks, during which the team commits to completing a defined set of tasks. At the end of each sprint, the team reviews what was built and plans the next one. (Example: 'We ship a new version of the app at the end of every two-week sprint.')
Backlog: A prioritised list of all the features, fixes, and tasks a team wants to work on eventually. Items at the top are most important and most likely to be built; items at the bottom may never happen. The product manager owns the backlog. (Example: A backlog might have 80 items — only the top 10 are detailed enough to build.)
Epic: A large body of work that gets broken down into smaller user stories or tasks. An epic captures a big theme that might span multiple sprints. (Example: 'User Authentication' is an epic containing stories like sign up, log in, reset password, and two-factor auth.)
User Story: A short, plain-English description of a feature written from the user's perspective: 'As a [type of user], I want to [action], so that [benefit].' User stories keep the team focused on outcomes rather than technical tasks. (Example: 'As a new user, I want to sign up with Google so that I don't have to create another password.')
Story Points: A unit used to estimate the relative effort of a user story — not hours, but complexity. Teams agree on points together (often using Fibonacci numbers: 1, 2, 3, 5, 8) so everyone aligns on what 'small' and 'large' mean. (Example: A simple bug fix might be 1 point; a major new feature might be 13.)
Velocity: A measure of how many story points a team completes in a sprint, tracked over time. Velocity helps teams forecast how long future work will take and spot when something is slowing them down. (Example: If a team consistently delivers 30 points per sprint, a 90-point epic should take about 3 sprints.)
Definition of Done: A shared agreement on what 'finished' means for a piece of work. It prevents incomplete tasks from being marked done. (Example: A typical Definition of Done might include: code reviewed, tests written, QA passed, feature flag enabled, and documentation updated.)
Standup (Daily Scrum): A short daily team meeting — usually 15 minutes — where each person covers what they did yesterday, what they plan to do today, and any blockers. The goal is coordination, not status reporting. (Example: 'Yesterday I finished the search API. Today I'm working on the UI. Blocked on design feedback from Sarah.')
Sprint Planning: A meeting at the start of each sprint where the team selects items from the backlog, estimates effort, and commits to what they will deliver. Good sprint planning sets a realistic, focused goal. (Example: A two-hour planning session before a two-week sprint.)
Retrospective: A meeting at the end of each sprint where the team reflects on how they worked — what went well, what didn't, and what to improve. Retrospectives are about process, not product. (Example: 'What went well: fast decision-making. What didn't: QA bottleneck late in the sprint.')
Kanban: A visual workflow system where tasks move as cards across columns (typically 'To Do', 'In Progress', 'Done'). Kanban limits work in progress to help teams stay focused and expose bottlenecks. (Example: A support team might use Kanban instead of sprints because their work arrives continuously.)
WIP Limit: Work In Progress limit — a cap on how many tasks can be in progress at once in a Kanban system. WIP limits prevent multitasking and force teams to finish before starting something new. (Example: A WIP limit of 3 on 'In Progress' means no one starts a fourth task until one is done.)
Stakeholder: Anyone with an interest in the outcome of a project — executives, customers, partner teams, investors, legal. Managing stakeholder expectations (keeping them informed and aligned) is a core PM skill. (Example: For a payments feature, stakeholders include engineering, finance, legal, and customer success.)
PO (Product Owner): In Scrum, the person responsible for the backlog — defining, prioritising, and explaining what the team should build. In many companies, the product manager and product owner are the same person. (Example: The PO reviews every user story before it enters a sprint to ensure it has clear acceptance criteria.)
SM (Scrum Master): The person who facilitates Scrum ceremonies, removes blockers, and protects the team from distractions. The Scrum Master is a servant leader, not a manager. (Example: If a dependency on another team is blocking progress, the Scrum Master escalates and resolves it.)

Data & Analytics

DAU / MAU (Daily / Monthly Active Users): DAU counts unique users who interact with a product in a single day; MAU counts them over a month. The DAU/MAU ratio — sometimes called 'stickiness' — shows how often monthly users actually return each day. (Example: A ratio of 50% means the average user engages with the product 15 days per month.)
Retention: How well a product keeps users coming back over time, measured as the percentage still active after 7, 30, or 90 days. It is the single most important signal of whether a product delivers lasting value. (Example: 'Day 30 retention of 40%' means 40 out of every 100 new users are still active a month later.)
Churn: The rate at which users or customers stop using a product or cancel their subscription in a given period. High churn signals the product is not delivering lasting value. (Example: Monthly churn of 5% means a SaaS company loses 5% of its subscribers every month.)
Conversion Rate: The percentage of users who complete a desired action — signing up, purchasing, upgrading. A small improvement in conversion rate can have a large impact on revenue. (Example: If 100 people visit a pricing page and 5 upgrade, the conversion rate is 5%.)
Cohort Analysis: Tracking a group of users who share a common starting point (like sign-up month) over time to see how their behaviour changes. Cohort analysis reveals whether product improvements are actually working. (Example: Comparing the retention of users who signed up in January vs. March shows whether a new onboarding flow improved long-term engagement.)
Funnel: A series of steps users take toward a goal, like signing up or purchasing. Called a funnel because fewer people complete each step — many enter the top, fewer reach the bottom. Identifying where users drop off is key to improving conversion. (Example: A checkout funnel: view product → add to cart → enter payment → confirm order.)
A/B Test: An experiment where two variants are shown to different user groups to determine which performs better. Results must be statistically significant before drawing conclusions. (Example: Testing two different subject lines on a welcome email to see which gets a higher open rate.)
Statistical Significance: A measure of confidence that an A/B test result is real and not due to random chance. Most teams require 95% statistical significance before acting on an experiment result. (Example: 'The test reached significance after 2,000 users per variant — we can confidently roll out the winner.')
NPS (Net Promoter Score): A customer loyalty metric based on one question: 'How likely are you to recommend us to a friend, on a scale of 0–10?' Promoters (9–10) minus Detractors (0–6) gives the NPS. (Example: An NPS of 50 is considered excellent; negative NPS means more detractors than promoters.)
MRR / ARR (Monthly / Annual Recurring Revenue): The predictable revenue a subscription business earns each month (MRR) or year (ARR) from its current customers. Growing MRR is the primary signal of a healthy SaaS business. (Example: 100 customers paying $100/month = $10,000 MRR = $120,000 ARR.)
LTV (Lifetime Value): The total revenue a business expects to earn from a single customer over the entire relationship. Comparing LTV to CAC tells you whether the business model is sustainable. (Example: If a customer pays $50/month for an average of 24 months, their LTV is $1,200.)
CAC (Customer Acquisition Cost): The total cost of acquiring a new customer, including marketing, sales, and related overhead. A sustainable business needs LTV to be significantly higher than CAC — typically 3x or more. (Example: Spending $10,000 to acquire 100 customers = $100 CAC.)
NRR (Net Revenue Retention): A measure of how much recurring revenue is retained from existing customers after accounting for churn, downgrades, and expansions. NRR above 100% means existing customers are spending more over time. (Example: NRR of 120% means customers who spent $100 last year are now spending $120 on average — even without counting new customers.)
Dashboard: A visual display of key metrics in a single screen, letting teams monitor performance at a glance without digging through raw data. (Example: A product dashboard might show DAU, retention, MRR, and top features used — all updating in real time.)
Data Pipeline: An automated system that moves and transforms data from one place to another — usually from raw event logs to a clean data warehouse. (Example: A pipeline might collect every button click from the app, clean the data, and load it into BigQuery where analysts can query it.)

UX & Design

IA (Information Architecture): The way content and features are organised, labelled, and structured within a product. Good IA makes it easy for users to find what they are looking for; bad IA leaves them lost. (Example: Deciding whether 'Settings' lives in the top nav or a profile dropdown is an IA decision.)
Wireframe: A low-fidelity sketch of a screen's layout — showing structure and hierarchy without colours, branding, or final copy. Wireframes are fast to produce and easy to change, making them ideal for exploring ideas early. (Example: A wireframe for a sign-up page would show the form fields and button placement, nothing more.)
Prototype: An early, often interactive model of a design used to test ideas with real users before writing production code. Prototypes range from paper sketches to pixel-perfect Figma flows. (Example: A clickable Figma prototype lets users simulate completing a checkout flow before a single line of code is written.)
Usability Test: A method of evaluating a design by watching real users try to complete specific tasks while you observe and take notes. Usability tests reveal problems the team — too close to the work — can no longer see. (Example: Asking five users to 'find the export button' often reveals in 30 minutes that the button is buried where no one looks.)
Design System: A shared library of reusable UI components, design tokens, and guidelines that ensures consistency across a product. A design system means every button, form, and card looks and behaves the same everywhere. (Example: Google's Material Design and Airbnb's Design Language System are well-known examples.)
Design Token: A named variable that stores a design decision — a colour, a font size, a spacing value — so it can be used consistently across the product and updated in one place. (Example: A token named `--color-primary` is defined once as '#2563EB' and used in every button and link.)
Component Library: A collection of pre-built, reusable UI elements — buttons, inputs, modals, cards — that designers and engineers use to build screens faster and more consistently. (Example: Instead of designing a new modal from scratch each time, a team pulls one from the component library.)
Accessibility (a11y): The practice of designing products so that people with disabilities — visual, motor, hearing, cognitive — can use them fully. 'a11y' is a numeronym for 'accessibility' (11 letters between a and y). (Example: Adding text descriptions to images so screen reader users can understand them.)
WCAG: Web Content Accessibility Guidelines — the international standard for web accessibility. WCAG defines levels (A, AA, AAA); most companies target AA as a minimum, covering colour contrast, keyboard access, and screen reader support. (Example: A WCAG AA requirement is that text must have a minimum 4.5:1 contrast ratio against its background.)
Design Sprint: A structured five-day process (created by Google Ventures) to solve a problem through design, prototype, and user testing — compressing months of work into a single week. (Example: A team uses a design sprint to test three different concepts for a new onboarding flow before committing to building any of them.)
Card Sort: A UX research method where participants group content labels into categories that make sense to them, helping teams understand how users think about information. (Example: Having users sort 30 navigation labels into groups reveals the mental model behind an ideal information architecture.)
Tree Test: A usability test that evaluates how easy it is to find items within a proposed navigation structure, without any visual design to distract from the pure hierarchy. (Example: Asking users to find 'How to cancel my subscription' within a proposed site tree, then measuring success rate and time taken.)
Persona: A fictional but research-backed profile of a typical user, capturing demographics, goals, frustrations, and behaviours. Personas give the team a concrete human to design for. (Example: 'Maya, 32, a marketing manager who needs to create campaign reports weekly but has no data background.')
Journey Map: A visual diagram that traces the steps a user takes when interacting with a product over time, including their thoughts, feelings, and pain points at each stage. (Example: A journey map for a job application might show excitement at discovery, frustration at a long form, anxiety during the wait, and relief at an offer.)
UX Research: The systematic study of users — through interviews, surveys, usability tests, and observation — to understand their needs, behaviours, and motivations. UX research grounds design decisions in evidence rather than assumption. (Example: Conducting 10 user interviews before redesigning an onboarding flow to understand where current users get stuck.)

Engineering (What You Will Hear)

Frontend: The part of an application that users see and interact with directly — the visual interface in a browser or app. Built with languages like HTML, CSS, and JavaScript. (Example: The buttons, forms, and layouts on a website are all frontend work.)
Backend: The server-side of an application — the logic, database, and APIs that power what users see on the frontend. Users never interact with the backend directly. (Example: When you log in, the backend checks your credentials against the database and decides whether to grant access.)
Full Stack: A developer who works across both frontend and backend. Full-stack engineers can build a complete feature from the database to the user interface. (Example: A full-stack developer might write the database query, the API endpoint, and the UI component for a new search feature.)
API: Application Programming Interface. A set of rules that lets two software systems communicate. APIs are what allow apps to share data and trigger actions in other services. (Example: When an app lets you 'Log in with Google', a Google API is doing the verification behind the scenes.)
Repository (Repo): A storage location for a project's code, managed using a version control system like Git. Teams use repos to collaborate on code without overwriting each other's work. (Example: A GitHub repository holds all the code for a product, along with its full history of changes.)
PR (Pull Request): A way for a developer to propose changes to a codebase and request that teammates review and approve them before they are merged into the main branch. (Example: A developer opens a PR to add a new feature; two teammates review the code, leave comments, and approve it before it ships.)
Deploy: The process of releasing code from a development environment to a live server where real users can access it. 'Deploying to production' means pushing changes live. (Example: After QA approves a sprint, the team deploys the new features to the production environment.)
Environment (Dev / Staging / Prod): Separate copies of a software system used at different stages of development. Dev is where engineers write code; Staging mirrors production for final testing; Prod (production) is what real users see. (Example: 'It works on Staging but not Prod' is a common and stressful sentence in tech.)
CI/CD: Continuous Integration / Continuous Deployment. A set of automated processes that test and deploy code every time a change is made, reducing the risk of bugs reaching users. (Example: A CI/CD pipeline automatically runs tests on every PR and deploys code to staging when it passes.)
Technical Debt: The accumulated cost of shortcuts and quick fixes that made sense in the short term but now slow the team down. Like financial debt, it compounds — the longer it is left, the more expensive it becomes to fix. (Example: A feature built quickly for a launch that now needs to be rebuilt properly before anything new can be added to it.)
Refactor: Rewriting existing code to make it cleaner, faster, or easier to maintain — without changing what it does for users. Refactoring pays down technical debt. (Example: Replacing a tangled 500-line function with a set of smaller, well-named functions that do the same thing.)
Bug: An error or flaw in software that causes it to behave in an unintended way. Bugs range from minor visual glitches to critical outages. Finding and fixing them is called debugging. (Example: A bug that shows a user's cart as empty after they add items is a critical bug that needs immediate fixing.)
QA (Quality Assurance): The process of testing software to find bugs and ensure it meets requirements before it reaches users. QA engineers write test cases, run them manually or automatically, and report issues back to developers. (Example: QA testing a new checkout flow by trying every possible edge case — empty fields, invalid cards, network drops.)
Unit Test: An automated test that checks a single, isolated piece of code (a function or component) to ensure it works correctly on its own. (Example: A unit test for a price calculation function would verify that 10% off $100 returns $90, not $90.01 or $89.99.)
Integration Test: An automated test that checks whether multiple parts of a system work correctly together — not just individually. (Example: An integration test for a signup flow tests the form, the API call, the database write, and the welcome email together, not each piece in isolation.)

Business & Monetization

SaaS: Software as a Service. A software delivery model where the product is hosted in the cloud and accessed via a subscription, usually through a web browser. (Example: Slack, Notion, HubSpot, and Salesforce are all SaaS products.)
B2B: Business-to-business. A company that sells its product or service to other companies rather than to individual consumers. B2B deals are often larger, slower to close, and require formal sales processes. (Example: Salesforce selling CRM software to enterprises is B2B.)
B2C: Business-to-consumer. A company that sells directly to individual people, often through self-serve sign-up and low-friction purchase flows. (Example: Netflix, Spotify, and Duolingo are classic B2C companies.)
Freemium: A business model where a basic version of the product is free and users pay to unlock more features, higher limits, or advanced capabilities. (Example: Spotify is free with ads; a premium subscription removes ads and adds downloads.)
Free Trial: A time-limited period — typically 7, 14, or 30 days — where users can access a paid product for free before deciding whether to subscribe. Different from Freemium, where the free tier is permanent. (Example: 'Start your 14-day free trial — no credit card required.')
Enterprise: The segment of the market consisting of large organisations — typically companies with hundreds or thousands of employees. Enterprise deals are high-value, involve procurement and security reviews, and require dedicated sales and customer success. (Example: An enterprise contract might be $200,000 per year and take six months to close.)
SMB (Small and Medium-Sized Business): Companies with fewer employees and smaller budgets than enterprise customers. SMB customers typically buy through self-serve or low-touch sales, at lower contract values. (Example: A 20-person agency paying $300/month for a SaaS tool is an SMB customer.)
ACV (Annual Contract Value): The average annual revenue from a single customer contract. ACV helps teams understand deal size and how much to invest in acquiring and retaining each customer. (Example: Selling a $36,000 two-year deal means an ACV of $18,000.)
Tier: A pricing level that groups features and limits into packages — typically Starter, Pro, and Enterprise. Each tier offers more capability at a higher price point. (Example: The Pro tier might include unlimited seats; the Starter tier caps users at five.)
Churned: A customer who has cancelled their subscription or stopped paying. Churned customers are gone — the goal is to prevent churn before it happens, not just react after. (Example: 'We churned 12 accounts last quarter, mostly SMBs who said they didn't use the product enough.')
Renewed: A customer who has extended their subscription at the end of a contract period. Renewals are a core metric for Customer Success teams. (Example: A customer on a 12-month contract who signs another 12-month deal has renewed.)
Upsell: Convincing an existing customer to upgrade to a higher-priced plan or add a premium feature. Upselling grows revenue from customers you already have. (Example: A customer on the Starter plan upgrading to Pro after needing more storage is an upsell.)
Expansion Revenue: Additional revenue generated from existing customers through upsells, cross-sells, or usage growth — as opposed to revenue from new customers. High expansion revenue is a sign of strong product value. (Example: A customer who started at $500/month and is now paying $2,000/month represents $1,500 in expansion revenue.)
Churn Rate: The percentage of customers or revenue lost in a given period. Keeping churn rate low is critical to sustainable growth — high churn means you are constantly filling a leaky bucket. (Example: Monthly churn of 3% compounds: you lose ~30% of customers per year without adding a single new one.)
Health Score: A composite metric used by Customer Success teams to predict whether an account is at risk of churning. It typically combines usage frequency, feature adoption, support tickets, and NPS responses. (Example: An account that has not logged in for 45 days and gave a low NPS score would have a low health score — triggering proactive outreach.)

Ready to use these terms?

Find the role that fits your background

You know the language. Now explore the roles that use it every day and discover which tech career is the right fit for you.

Explore tech roles Take the quiz