Reference

Glossary

Searchable definitions of PM, analytics, technical and AI terms.

175 terms

A/B test: A controlled experiment that randomly assigns eligible users to a control and a variant, then compares a pre-agreed metric. (Module 7)
AARRR: Pirate metrics: Acquisition, Activation, Retention, Revenue, Referral — a lens for diagnosing growth. (Module 7)
Acceptance criteria: Testable conditions a story must meet to be accepted, often written as Given / When / Then. (Module 6)
Accessibility: The degree to which people with different abilities can perceive, understand and use a product; commonly assessed against WCAG. (Module 5)
ACID: Atomicity, Consistency, Isolation, Durability — database transaction guarantees important for money and orders. (Module 9)
Activation: An early user behaviour that indicates the person has reached meaningful value; the right event depends on the product. (Module 7)
Affinity mapping: Clustering research observations into themes to synthesise insights. (Module 3)
Agent (AI agent): A system that uses a model and tools to work toward a goal, choosing steps based on intermediate results, within limits set by a person or policy. (Module 12)
Agile: A family of approaches that deliver in small increments and adapt using feedback (e.g., Scrum, Kanban). (Module 1)
Ansoff matrix: Growth options: market penetration, product development, market development, diversification. (Module 2)
AOV: Average order value: total order value ÷ number of orders for the same period and definition. (Module 7)
API: An agreed way for one piece of software to request data or an action from another; a request goes in, a response (data or error) comes back. (Module 9)
ARPU / ARPPU: Average revenue per user / per paying user over a period. (Module 7)
Assumption mapping: Plotting assumptions by importance and evidence to decide which to test first. (Module 3)
Attention (self-attention): Transformer mechanism that weighs how much each token should use information from every other token in the context. (Module 10)
Authentication (authN): Verifying who someone is (password, OTP, passkey, SSO). (Module 9)
Authorisation (authZ): Determining what an authenticated user is allowed to do (roles, permissions, scopes). (Module 9)
Availability: Share of time a system is usable, e.g., 99.9% allows about 43 minutes of downtime per 30-day month. (Module 9)
Backlog: An ordered list of work for a product or team; in Scrum, the Product Backlog. (Module 1)
BATNA: Best alternative to a negotiated agreement — your fallback if negotiation fails. (Module 6)
Beta test: Release to external users before general availability to find problems and gather feedback; different from an A/B test. (Module 8)
Blue Ocean Strategy: Creating uncontested market space by reshaping value (eliminate, reduce, raise, create) rather than competing head-on. (Module 2)
Build–Measure–Learn: The Lean Startup feedback loop: build an MVP, measure, learn, and decide to pivot or persevere. (Module 4)
Business Model Canvas: Nine-block description of how an organisation creates, delivers and captures value. (Module 2)
CAC: Customer acquisition cost: acquisition spend ÷ new customers acquired, with costs explicitly defined. (Module 7)
Cache: Fast storage of frequently used data to reduce latency and load; trades freshness for speed. (Module 9)
CDN: Content delivery network: servers near users that cache static content. (Module 9)
Churn: The proportion of customers (or revenue) lost over a defined period from a defined starting group. (Module 7)
CI/CD: Continuous integration and continuous delivery/deployment: automatically build, test and release code changes. (Module 9)
Cognitive load: Mental effort required to use an interface; designers reduce extraneous load. (Module 5)
Cohort: A group of users who share a starting event or period, such as signing up in the same week. (Module 7)
Confidence interval: A range of effect sizes consistent with the data, produced by a procedure that captures the true value at a stated rate (e.g., 95%). (Module 7)
Context window: The limit on how much text (in tokens) a model can process in one request, including instructions, input and output. (Module 10)
Contribution margin: Revenue minus specified variable costs for a unit (such as an order). Not the same as net profit because fixed costs are excluded. (Module 7)
CORS: A browser security mechanism controlling which origins may make requests to a server — not a synonym for all UI–API communication. (Module 9)
Cosine similarity: A measure of similarity between two vectors based on the angle between them (−1 to 1). (Module 10)
Cost of Delay: The value lost per unit time by not having something; used to prioritise time-sensitive work. (Module 4)
Customer journey map: A visual of a persona's stages, actions, thoughts, emotions, touchpoints and pain points across an experience. (Module 3)
DACI: Decision framework: Driver, Approver, Contributors, Informed. (Module 6)
DAU / WAU / MAU: Distinct users with a qualifying action in a day, week or month. (Module 7)
Definition of Done: A team's shared quality criteria for completed work. (Module 1)
Definition of Ready: Criteria a team may use before starting work on an item. (Module 1)
Dependency: Work or a decision that another piece of work relies on. (Module 4)
Design system: A shared library of tokens, components, patterns and guidelines (and code) for consistent UI. (Module 5)
Design Thinking: A human-centred, iterative approach: empathise, define, ideate, prototype, test. (Module 5)
Discovery: Work to decide what is worth building by learning about users, problems and solutions before and during delivery. (Module 3)
Double Diamond: Design process model: discover and define the right problem, develop and deliver the right solution. (Module 5)
Dual-track agile: Running discovery and delivery in parallel so validated ideas continuously feed the backlog. (Module 1)
Embedding: A list of numbers made by a model to represent an item for tasks such as similarity search. (Module 10)
Epic: A large body of work broken into smaller stories. (Module 6)
Error budget: Allowed unreliability implied by an SLO (100% − SLO) over a period. (Module 9)
Evaluation (eval): A repeatable set of test cases and scoring rules for an AI system. (Module 10)
Event instrumentation: Adding tracking so that user actions become analytics events with defined names and properties. (Module 7)
Feature flag: A switch to turn functionality on or off, or for a subset of users, without redeploying. (Module 9)
Fine-tuning: Additional training that changes a model's parameters to adjust behaviour; it does not add live knowledge or guarantee truth. (Module 10)
First principles thinking: Breaking a problem into fundamental truths and reasoning up from them instead of by analogy. (Module 4)
Fishbone diagram: Ishikawa diagram organising possible causes by category. (Module 4)
Fitts's law: Time to reach a target depends on distance and size: T = a + b log₂(D/W + 1). (Module 5)
Five Whys: Asking 'why?' repeatedly to move from a symptom toward a root cause; each step needs evidence. (Module 4)
Focus group: A moderated research discussion with a group of participants — not another name for a target audience. (Module 3)
Freemium: A model with a usable free tier and paid upgrades. (Module 8)
Function calling (tool calling): A model outputs a structured request to run a defined tool; the application executes it and returns the result. (Module 12)
Funnel: A sequence of steps toward a goal with counts at each step; used to find drop-offs. (Module 7)
Gestalt principles: Perception principles (proximity, similarity, closure, etc.) describing how people group visual elements. (Module 5)
GMV: Gross merchandise value: total value of orders through a marketplace in a period — not the platform's revenue. (Module 7)
Go-to-market (GTM): The plan for reaching, converting and supporting the right customers: audience, positioning, pricing, channels, readiness and measurement. (Module 8)
GraphQL: An API query language where clients request exactly the fields they need from a typed schema. (Module 9)
Grounding: Tying model outputs to verifiable sources, e.g., via retrieval and citations. (Module 10)
Growth loop: A system where the output of one cycle (e.g., new users) becomes input to the next, compounding growth. (Module 8)
Guardrail metric: A metric watched to ensure that improving the main metric does not cause harm elsewhere (for example complaints or refund rate). (Module 7)
Guesstimate: A structured estimate built from explicit assumptions, ideally with two methods and a range. (Module 3)
Hallucination: Model-generated content that is false or unsupported by the provided sources. (Module 10)
HEART: UX metrics framework: Happiness, Engagement, Adoption, Retention, Task success. (Module 5)
Heuristic evaluation: Expert review of an interface against usability principles such as Nielsen's 10 heuristics. (Module 5)
Hick's law: Decision time grows with the number and complexity of choices: T = b log₂(n + 1). (Module 5)
Human-in-the-loop (HITL): Placing people at key points of an AI system to review, approve or handle exceptions. (Module 10)
Hypothesis: A clear, testable prediction, e.g. 'We believe that change X will improve metric Y for users Z because R'. (Module 4)
ICE: Prioritisation score: Impact × Confidence × Ease (1–10 scales). (Module 4)
Idempotency: Property where repeating an operation has the same effect as doing it once; vital for retried payments. (Module 9)
Information architecture: How content is organised, labelled and navigated so people can find it. (Module 5)
Jakob's law: Users expect your product to work like the others they already use. (Module 5)
Jobs to Be Done (JTBD): Framing demand as the progress people seek in a particular circumstance. (Module 3)
JSON: A text data format of key–value pairs and lists commonly used by APIs. (Module 9)
K-factor: Viral coefficient: invites per user × invite conversion rate. (Module 8)
Kanban: A method for visualising and improving flow, including limiting work in progress. (Module 1)
Kano model: Classifies features as must-be, performance, attractive, indifferent or reverse by their effect on satisfaction. (Module 4)
KPI: Key performance indicator: a metric chosen to assess progress toward an important goal. (Module 7)
Latency: Time to respond to a request; reported as percentiles such as p50, p95, p99. (Module 9)
Lean Canvas: A startup-oriented business model canvas focused on problem, solution, key metrics and unfair advantage. (Module 2)
Lean Startup: Approach that reduces waste by testing business hypotheses with MVPs and validated learning. (Module 4)
LLM: Large language model: a model trained on large amounts of text that generates text by predicting likely next tokens given its context. (Module 10)
Load balancer: Distributes requests across servers and removes unhealthy ones. (Module 9)
LoRA: Low-Rank Adaptation, a parameter-efficient fine-tuning technique — not a standalone model. (Module 10)
LTV: Lifetime value: estimated future contribution from a customer under assumptions about retention and margin. (Module 7)
MCP: Model Context Protocol: a standard way for AI applications to connect to external tools and resources. It does not replace every API and does not by itself grant permission. (Module 12)
Microservices: An architecture of small services each owning a capability and its data, deployed independently. (Module 9)
Minimum detectable effect (MDE): The smallest effect an experiment is designed to detect; smaller MDE needs much larger samples. (Module 7)
Monolith: A single deployable application containing most functionality. (Module 9)
MoSCoW: Scope prioritisation into Must, Should, Could and Won't (this time) for a release. (Module 4)
MVP: Minimum viable product: the smallest useful version or experiment that lets a team learn about an important assumption with real users. Not the same as a prototype or a public launch. (Module 4)
Network effect: When each additional user makes the product more valuable to others; often local and weakened by multi-homing. (Module 2)
North Star metric: A chosen measure of recurring user value that also supports sustainable business results; supported by input metrics and guardrails. (Module 7)
NRR: Net revenue retention: (start MRR + expansion − contraction − churn) ÷ start MRR. (Module 8)
OAuth 2.0: A standard for delegated authorisation using scoped access tokens instead of sharing passwords. (Module 9)
Observability: Understanding system behaviour from logs, metrics and traces. (Module 9)
OKR: Objectives and Key Results: a qualitative objective with measurable key results. (Module 2)
Opportunity Solution Tree: A visual linking a desired outcome to customer opportunities, solutions and experiments. (Module 3)
Outcome: A change in user behaviour or business results caused by what the team shipped (as opposed to the output itself). (Module 1)
Output: What a team produces: features shipped, tickets closed, story points. Not evidence of value on its own. (Module 1)
p-value: The probability of seeing a result at least as extreme as observed if there were truly no effect; not the probability the variant works. (Module 7)
Pareto analysis: Ranking causes by frequency or impact to focus on the vital few. (Module 4)
Payback period: Time to recover CAC from contribution: CAC ÷ monthly contribution per customer. (Module 7)
PCI DSS: Payment card industry data security standard governing handling of card data. (Module 9)
Persona: An illustrative profile of a user segment, ideally built from research; a learning aid, not proof that everyone in a group behaves alike. (Module 3)
PESTLE: Macro scan: Political, Economic, Social, Technological, Legal, Environmental. (Module 2)
Pivot: A substantive change in strategy based on evidence — not every small iteration. (Module 4)
Porter's Five Forces: Industry analysis of rivalry, new entrants, substitutes, buyer power and supplier power. (Module 2)
Positioning: How a product is defined for a target customer relative to alternatives. (Module 2)
Power (statistical): The probability an experiment detects a real effect of a given size; commonly targeted at 80%. (Module 7)
PRD: Product requirements document: a shared explanation of the problem, users, goals, scope, requirements, success metrics, risks and open questions. (Module 6)
Product Owner: Scrum accountability for maximising product value and managing the Product Backlog; may or may not be the PM. (Module 1)
Product-led growth (PLG): Growth where the product drives acquisition, conversion and expansion through self-serve use. (Module 8)
Product-market fit: A state where a product satisfies a real market need strongly enough that customers keep using, paying for and recommending it. (Module 1)
Prompt engineering: Designing instructions, context, examples and output formats to get reliable model outputs. (Module 10)
Prompt injection: Untrusted text containing instructions that try to hijack an AI system's behaviour. (Module 12)
Prototype: An early model used to explore or test an idea; it may be paper, a clickable design or a partly working app, and may not include real backend services. (Module 11)
Pull request (PR): A proposed set of code changes for review before merging. (Module 11)
Pyramid Principle: Communication structure that starts with the answer and supports it with grouped arguments and evidence. (Module 6)
Queue (message queue): A buffer where producers place work for consumers to process asynchronously. (Module 9)
Quick ratio (SaaS): (New + expansion + reactivation MRR) ÷ (churned + contraction MRR). (Module 8)
RACI: Responsible, Accountable, Consulted, Informed — a responsibility matrix. (Module 6)
RAG: Retrieval-augmented generation: find relevant source material at question time, give it to a language model with the question, and generate an answer grounded in it. It does not retrain the model and does not require a vector database. (Module 10)
Rate limit: A cap on requests per time window; exceeding it typically returns HTTP 429. (Module 9)
Repository: A project folder with version history (e.g., in Git/GitHub). (Module 11)
REST: An architectural style for APIs organised around resources and standard HTTP methods. (Module 9)
Retention: How many users return or continue to receive value over a defined period, measured for a defined cohort and window. (Module 7)
RICE: A prioritisation score: Reach × Impact × Confidence ÷ Effort. A discussion aid, not an automatic decision. (Module 4)
Root cause analysis (RCA): Investigating the underlying causes of a problem so it can be prevented, not just patched. (Module 4)
Sample ratio mismatch (SRM): When observed group sizes differ from the planned split more than chance allows — a sign the experiment may be broken. (Module 7)
Scrum: An Agile framework with sprints, defined accountabilities (Product Owner, Scrum Master, Developers), events and artefacts. (Module 1)
Segment: A group of users sharing a relevant need or behaviour. (Module 3)
Semantic search: Search by meaning using embeddings rather than exact keywords. (Module 10)
SLI / SLO / SLA: Service level indicator (measurement), objective (target) and agreement (contractual promise). (Module 9)
Sprint: A time-box in Scrum of one month or less during which a team works toward a Sprint Goal. (Module 1)
SQL: Structured Query Language for querying and managing relational data. (Module 7)
STAR: Situation, Task, Action, Result — structure for behavioural interview answers. (Module 6)
Statistical significance: A result unlikely under the null hypothesis at a pre-set threshold α; not the same as practical importance. (Module 7)
Stickiness: DAU ÷ MAU — how often monthly users engage on a typical day. (Module 7)
Story points: Relative effort estimates used by a team for planning — not a productivity score. (Module 6)
SUS: System Usability Scale: a 10-item questionnaire scored 0–100 (around 68 is often cited as average). (Module 5)
SWOT: Strengths, Weaknesses, Opportunities, Threats. (Module 2)
Systems thinking: Analysing feedback loops, delays and interactions to avoid local optimisation with hidden side effects. (Module 4)
TAM / SAM / SOM: Total addressable market, serviceable available market, serviceable obtainable market: successively narrower estimates of demand under explicit assumptions. (Module 2)
Technical debt: The future cost of a technical shortcut or outdated implementation; not every bug is technical debt. (Module 9)
Temperature: A sampling setting controlling randomness in model outputs; lower is more deterministic. (Module 10)
Throughput: Number of requests or transactions processed per unit time. (Module 9)
Token: A unit of text (word, sub-word or punctuation) processed by a language model. (Module 10)
Transformer: Neural network architecture based on self-attention, underlying modern LLMs. (Module 10)
Triangulation: Reaching conclusions from multiple independent types of evidence. (Module 3)
Type I / Type II error: False positive (finding an effect that isn't real) / false negative (missing a real effect). (Module 7)
UAT: User acceptance testing: checking whether a solution meets user or business acceptance needs before release. (Module 1)
Unicorn: A privately held company valued at $1 billion or more (valuation, not revenue). (Module 2)
Unit economics: Revenue and costs for a single unit (order, customer) to judge whether growth is sustainable. (Module 7)
Usability test: Observing representative users attempting realistic tasks to find problems. (Module 5)
User flow: The path of steps and decisions a user takes within a product to reach a goal. (Module 5)
User story: A short description of a capability from the user's perspective: As a … I want … so that … (Module 6)
UX / UI: UX is the whole experience of achieving a goal; UI is the interface people see and use (controls, layout, typography). (Module 5)
Value proposition: A statement of the benefit a customer gets and why it beats alternatives. (Module 2)
Vector database: A store optimised for finding embeddings similar to a query; complements, not replaces, transactional databases. (Module 10)
Vibe coding: Building software by describing goals in natural language to an AI coding tool and iterating on the results. (Module 11)
WCAG: Web Content Accessibility Guidelines (currently 2.2), organised around perceivable, operable, understandable and robust. (Module 5)
Webhook: An HTTP callback sent by one system to another when an event occurs. (Module 9)
Wireframe: A low-fidelity layout showing structure and content priority without visual polish. (Module 5)
Workflow (automation): A predefined sequence of steps executed automatically; more predictable than an agent. (Module 12)
WSJF: Weighted Shortest Job First: Cost of Delay ÷ job size. (Module 4)