Agile prioritises flexibility, customer feedback, and rapid iterations, but navigating the jargon can be overwhelming for newcomers and even seasoned practitioners. This comprehensive Agile glossary is designed to demystify the most common terms and practices used in Agile, from the foundational concepts like user stories and sprints, to more advanced techniques like Behavior Driven Development (BDD) and continuous deployment.
Whether you’re a developer, product owner, scrum master, or simply curious about Agile, this glossary will serve as a handy reference to clarify terminology and enhance your understanding of Agile processes. Each term is explained with practical examples and context, ensuring that you’re not just familiar with the words, but also with how they are applied in real-world Agile environments. Explore the glossary below and get equipped with the knowledge to navigate your Agile journey confidently.
A
Acceptance Test Driven Development (ATDD)
ATDD involves the entire team (customers, developers, testers) working together to create acceptance tests that define the expected behavior of the system before any code is written. This process ensures all team members have a shared understanding of the requirements and improves collaboration and product quality.
Acceptance Testing
Acceptance testing verifies if a product meets the business requirements and is ready for delivery. It is typically conducted by stakeholders to ensure the system works as expected in real-world scenarios. These tests can include user acceptance testing (UAT), operational acceptance testing (OAT), and contract acceptance testing.
AntiPattern
An antipattern looks like a commonly followed solution but actually produces more problems than it solves. It represents practices that initially appear beneficial but lead to negative outcomes, like technical debt or poor team dynamics. Common examples include “Death March” and “God Class.”
Automated Build
An automated build process assembles the software application, compiling code, running automated tests, packaging, and deploying it to a testing or production environment. It integrates into continuous integration (CI) pipelines, ensuring reliability and reducing the risk of human error.
B
Backlog Refinement (Grooming)
Backlog refinement is a recurring event in Agile where the product owner and team review and prioritize items in the product backlog. This helps prepare stories for upcoming sprints, ensures that items are ready for development, and identifies dependencies or blockers early on.
Behavior Driven Development (BDD)
BDD extends TDD by focusing on specifying system behavior in natural language, making it understandable for both technical and non-technical team members. Scenarios are written in Given-When-Then format to describe the preconditions, actions, and outcomes.
Burndown Chart
A burndown chart visually represents the amount of work remaining over time in an iteration or project. It helps track progress against the iteration goal. A related chart, the burnup chart, shows work completed over time and the total scope of the project.
Business Agility
Business agility refers to an organization’s ability to quickly adapt to market changes, customer needs, and emerging opportunities while maintaining a focus on delivering value through flexible and responsive processes.
C
Collective Ownership
In Agile, collective ownership means that all team members share responsibility for the codebase. No individual owns a specific area, and anyone can change any part of the code to fix bugs, refactor, or add features, encouraging collaboration and reducing bottlenecks.
Continuous Deployment (CD)
Continuous Deployment is the extension of Continuous Integration (CI), ensuring that all changes that pass automated tests are automatically deployed to production. This requires rigorous testing, automation, and monitoring practices to ensure stability.
Continuous Integration (CI)
CI is the practice of automatically building and testing software as soon as changes are made. By integrating changes frequently, teams can identify and fix issues earlier, reducing the risk of integration problems later in development.
CRC Cards (Class-Responsibility-Collaborator)
CRC cards help design object-oriented systems by outlining the responsibilities of classes and their collaborations with other classes. These are physical index cards or digital representations that facilitate team discussions during design sessions.
Customer Development
Customer Development is a process introduced by Steve Blank for discovering, validating, and scaling products that meet customer needs. It focuses on gathering customer feedback early to guide product direction.
D
Daily Meeting (Daily Standup)
The daily meeting, also known as the standup, is a short, time-boxed event (typically 15 minutes) where team members share updates on their progress, plans for the day, and any blockers they face. This improves communication and keeps everyone aligned.
Definition of Done (DoD)
The Definition of Done is a shared understanding within the team of what must be completed for a product increment to be considered done. This often includes coding, testing, documentation, and review steps. The DoD ensures consistency in the quality of delivered features.
Definition of Ready (DoR)
The Definition of Ready outlines the criteria a user story must meet before being accepted into a sprint. Typically, it must be clear, well-defined, and small enough to complete within a sprint, with any dependencies resolved.
E
Epic
An epic is a high-level, large body of work that can be broken down into smaller user stories. Epics often represent broad project objectives and are divided into smaller, manageable increments to be tackled over multiple sprints.
Estimation
Estimation in Agile helps teams predict how long tasks or user stories will take to complete. Methods like Planning Poker or t-shirt sizing are used to reach a consensus on the complexity of a task, which can be measured in story points, hours, or other units.
Exploratory Testing
Exploratory testing is an unscripted testing approach where testers actively explore the software, leveraging their skills and intuition to discover bugs. It complements automated and scripted testing by uncovering issues that may not be anticipated in formal test cases.
Extreme Programming (XP)
XP emphasizes technical excellence and frequent releases in software development. Key practices include test-driven development (TDD), pair programming, continuous integration, and a focus on simplicity. XP aims to improve software quality and developer productivity.
F
Facilitation
Facilitation is the act of guiding team meetings, workshops, or other group activities. A good facilitator ensures that discussions stay on track, decisions are made, and everyone has the opportunity to contribute, fostering collaboration and consensus.
Frequent Releases
Frequent releases are central to Agile, enabling teams to deliver smaller, more manageable chunks of functionality frequently. This approach allows teams to respond quickly to feedback, reduce risks, and maintain a focus on customer value.
G
Given-When-Then
This is a common format for writing acceptance criteria and test cases in BDD. It describes the context (Given), the action (When), and the expected outcome (Then), making it easy to communicate the behavior of the system to both technical and non-technical stakeholders.
H
Heartbeat Retrospective
Heartbeat retrospectives occur at regular intervals (typically at the end of each sprint) to allow teams to reflect on what went well, what didn’t, and what can be improved. It fosters continuous improvement and team cohesion.
I
Incremental Development
Incremental development delivers software in pieces, with each increment providing a subset of the system’s overall functionality. The goal is to have a working product after each increment that can evolve and grow.
Information Radiators
Information radiators are visual displays (e.g., task boards, charts) that provide up-to-date information on the team’s progress and health. These radiators promote transparency and make it easy for stakeholders to understand the current status of the project at a glance.
Integration
Integration refers to the process of combining individual pieces of code into a functioning whole. Agile practices like continuous integration (CI) help teams identify integration issues early by merging code regularly.
INVEST
The INVEST acronym stands for Independent, Negotiable, Valuable, Estimable, Small, and Testable, which are criteria for writing high-quality user stories. Each user story should meet these criteria to ensure it is actionable and deliverable.
Iteration
An iteration is a time-boxed period, typically 1-4 weeks, in which a team develops and delivers a working increment of software. The iteration length remains consistent throughout the project to provide regular feedback and reflection.
Iterative Development
Iterative development means repeating the development cycle of planning, designing, coding, and testing to refine the product over time. It allows teams to adapt to feedback and make continuous improvements.
J
Jidoka
Jidoka is a Lean concept, often used in Agile, that emphasizes “automation with a human touch.” It involves stopping the process when an issue occurs, allowing immediate correction rather than letting the problem pass through the production line. In software development, this could mean halting further work when a significant defect is found, so the team can focus on resolving the issue before continuing.
Just-In-Time (JIT)
Just-In-Time refers to delivering materials, information, or resources only when they are needed for the next stage of the process. In Agile, this principle applies to planning and design: teams defer decision-making and commitment to specific features or designs until the last responsible moment, ensuring they are based on the most up-to-date information.
Job Stories
Job Stories are an alternative to User Stories, focusing on the motivation behind a task. Instead of describing a feature as “As a [role], I want [feature] so that [benefit],” a Job Story takes the format “When [situation], I want to [action], so I can [outcome].” This format shifts the focus from who the user is to what job they need to get done and why.
K
Kanban
Kanban is a visual method for managing workflow. It limits work in progress (WIP) to improve efficiency and helps teams visualize tasks moving through stages, from “To Do” to “Done,” while aiming for continuous delivery.
Kanban Board
A Kanban Board is a visual tool that represents the status of work items through columns such as “To Do,” “In Progress,” and “Done.” It helps teams track work visually, ensuring transparency and flow.
L
Lead Time
Lead Time measures the duration between the initiation of a task (e.g., when a story is added to the backlog) and its completion (when the story is done). This helps teams assess efficiency and delivery speed.
M
Milestone Retrospective
A milestone retrospective is a more in-depth reflection meeting conducted at significant project milestones (e.g., the end of a release cycle) to review overall progress and key learnings.
Minimum Marketable Feature (MMF)
MMF refers to the smallest piece of functionality that can be delivered that adds value to the customer and can stand on its own. MMFs are often used to determine the minimal scope required for a release.
Minimum Viable Product (MVP)
An MVP is a product with just enough features to satisfy early customers and provide feedback for future product development. It allows for fast learning and avoids investing too much effort in features that may not be needed.
Mob Programming
Mob Programming is an approach where the entire team collaborates on one task at the same time and at the same workstation. This highly collaborative approach leverages collective knowledge, reducing silos and accelerating problem-solving.
Mock Objects
Mock objects simulate the behavior of real objects in controlled ways during automated tests. This allows for isolated unit testing of components without needing the actual dependencies, ensuring tests run quickly and reliably.
N
Niko-niko Calendar
The Niko-niko (or “smiley face”) calendar is used to track the mood of team members each day. This visual tool helps reveal emotional trends over time, enabling teams to address potential morale issues and improve overall team well-being.
O
Open Space
Open Space is a type of meeting or workshop format where participants set the agenda and run sessions based on topics of interest. It fosters creativity, innovation, and peer-to-peer learning by allowing participants to decide what’s most relevant to them.
P
Pair Programming
Pair programming is an Agile software development technique where two programmers work together at one workstation. One writes the code (driver), while the other reviews each line of code as it is written (navigator). The two programmers frequently switch roles to improve code quality and knowledge sharing.
Personas
Personas are fictional characters created to represent different user types who might use a service, product, or site. These personas are based on user research and help guide decisions about product features, interactions, and visual design by keeping the team focused on the user.
Planning Poker
Planning Poker is a consensus-based estimation technique used by Agile teams. Team members use a set of numbered cards to provide their estimate for a task. The numbers represent relative size or effort in completing the work. After discussion, team members vote until consensus is reached.
Points (estimates in)
Points in Agile refer to the unit of measurement used for estimating the effort required to complete a user story. Story points reflect the complexity and uncertainty of the work rather than the time it will take.
Product Backlog
The Product Backlog is an ordered list of everything that might be needed in the product, and it is the single source of work for the Scrum team. It evolves as new requirements, feedback, or changes are identified.
Product Owner
The Product Owner is the individual responsible for managing the product backlog and ensuring that the development team is working on the most valuable features. They represent the customer’s interests and provide guidance on what to build next.
Project Chartering
Project chartering is the process of defining the key objectives, scope, stakeholders, and success criteria of a project. It establishes a clear understanding among team members and stakeholders of what the project aims to achieve.
Q
Quick Design Session
A quick design session is an impromptu meeting where team members discuss a small design decision that has significant consequences for the system. It is typically informal and happens when necessary to resolve a specific issue.
R
Refactoring
Refactoring is the process of restructuring existing code without changing its external behavior. The goal is to improve code readability, reduce complexity, and make the code easier to maintain and extend in the future.
Relative Estimation
Relative estimation involves comparing user stories to one another based on their complexity or effort required rather than estimating time directly. It helps teams assess work using a more intuitive approach by categorizing tasks as small, medium, or large relative to each other.
Rules of Simplicity
The Rules of Simplicity, proposed by Kent Beck in the context of Extreme Programming (XP), define criteria for maintaining simple and clean code. The rules are: 1) The code runs all tests; 2) It contains no duplication; 3) It expresses every idea needed; 4) It minimizes the number of entities (classes, methods, etc.).
S
Scrum
Scrum is an Agile framework for managing complex projects. It divides work into iterations called sprints, typically lasting 2-4 weeks. Teams focus on delivering a potentially shippable product increment at the end of each sprint. Scrum includes key roles like Scrum Master, Product Owner, and development team.
Scrum Master
The Scrum Master is responsible for ensuring the Scrum team adheres to Agile values, practices, and principles. They facilitate Scrum events, remove impediments, and act as a coach to help the team perform at their best.
Scrum of Scrums
Scrum of Scrums is a technique used when scaling Scrum across multiple teams. Representatives from each team meet regularly to discuss progress and coordinate their efforts, ensuring all teams are aligned and working toward the same goals.
Scrumban
Scrumban is a hybrid of Scrum and Kanban methodologies. It combines the structured sprints of Scrum with the continuous flow of work in Kanban. Scrumban is particularly useful for teams transitioning from Scrum to a more flow-based process.
Sign Up for Tasks
In Agile, team members “sign up” for tasks voluntarily based on their skills, capacity, or interest rather than having tasks assigned by a manager. This practice promotes accountability and ownership of work.
Simple Design
Simple design refers to a development practice where the simplest solution that works is chosen. The goal is to reduce complexity, making the system easier to understand, maintain, and modify.
Sprint Backlog
The Sprint Backlog is a list of tasks the development team commits to completing during the current sprint. It is a subset of the product backlog, selected during sprint planning, and contains the highest-priority user stories that the team believes they can complete within the sprint.
Story Mapping
Story Mapping is a technique used to visualize and arrange user stories along two dimensions: the sequence of user activities and the importance of those activities. It helps teams understand the user’s journey and prioritize development work accordingly.
Story Splitting
Story splitting involves breaking down larger user stories (often epics) into smaller, more manageable stories. Each smaller story should still provide measurable business value and be independently testable.
Sustainable Pace
Sustainable pace refers to the practice of working at a consistent, manageable pace that can be maintained over the long term without leading to burnout. Teams avoid working excessive hours to ensure steady, long-term productivity.
T
Task Board
A Task Board is a visual tool, usually physical or digital, that displays the current status of work in progress. It typically has columns such as “To Do,” “In Progress,” and “Done,” with cards or sticky notes representing tasks.
TDD (Test-Driven Development)
Test-Driven Development (TDD) is a practice where developers first write a test for a small piece of functionality, then write the code to make that test pass, and finally refactor the code. TDD helps ensure that code is reliable and meets requirements from the start.
Team
In an Agile context, a team is a cross-functional group of people working together toward a shared goal. Agile teams are self-organizing, meaning they decide how best to complete their work within the given time constraints.
Team Room
A team room is a dedicated workspace for Agile teams to collaborate in. It allows for face-to-face communication, easy access to visual tools like task boards or information radiators, and fosters an open and collaborative environment.
The Three C’s
The Three C’s in Agile stand for Card, Conversation, and Confirmation. It’s a formula used for writing user stories. The “Card” represents the brief user story, the “Conversation” refers to the discussion between the team and stakeholders, and “Confirmation” defines the acceptance criteria.
Three Amigos
The Three Amigos refers to a collaboration between three roles—Business Analyst (or Product Owner), Developer, and Tester—who discuss a feature or user story from three perspectives: business value, technical feasibility, and testability.
Three Questions
In Agile daily standups, team members typically answer three questions: What did you do yesterday? What will you do today? What obstacles are in your way? This helps keep everyone informed and aligned.
Timebox
A timebox is a fixed duration of time in which an activity or event must be completed. In Agile, iterations (sprints) are timeboxed, meaning they last a set period of time, usually 1-4 weeks, and the work must be completed within that time.
U
Ubiquitous Language
Ubiquitous Language is a shared vocabulary used by developers, domain experts, and stakeholders in a project. It ensures that everyone speaks the same language when discussing the system’s requirements, design, and implementation, reducing misunderstandings.
Unit Testing
Unit Testing is the practice of testing individual units or components of a software application to ensure they behave as expected. Each unit test is designed to validate the functionality of a small, isolated part of the code.
Usability Testing
Usability Testing is an evaluation technique where real users interact with the software to see how easy it is to use. The feedback helps identify usability issues, allowing teams to make improvements that enhance user satisfaction.
User Stories
User Stories are short, simple descriptions of a feature or functionality written from the perspective of the end user. They typically follow the format: “As a [role], I want [feature] so that [reason].” They help communicate requirements in a way that’s easy to understand.
User Story Template
The User Story Template follows a specific format: “As a [user role], I want [goal] so that [benefit].” This format ensures that user stories focus on the user’s needs and the value that a feature provides.
V
Velocity
Velocity is a measure of the amount of work a team can complete during a sprint. It is typically calculated as the sum of the story points for all the user stories completed within a sprint, and helps forecast future performance.
Version Control
Version Control is a system that records changes to a file or set of files over time so that specific versions can be recalled later. In Agile, version control systems (like Git) enable continuous integration and allow teams to collaborate on the same codebase.
W
WIP (Work In Progress)
WIP refers to the amount of work currently being worked on by the team. Limiting WIP is an important principle in Agile methodologies such as Kanban, where the focus is on completing tasks before starting new ones. Reducing WIP improves flow and reduces context-switching, leading to higher efficiency and better quality work.
Wireframe
A wireframe is a low-fidelity visual representation or blueprint of a user interface. Wireframes show the basic structure and layout of a page or screen without including detailed design elements such as colors or graphics. They help stakeholders visualize the product’s functionality early in the development process.
X
XP (Extreme Programming)
XP is an Agile software development framework that focuses on improving software quality and responsiveness to changing customer requirements. XP promotes technical practices like test-driven development (TDD), pair programming, and continuous integration, emphasizing frequent releases and close collaboration with customers.
Y
YAGNI (You Aren’t Gonna Need It)
YAGNI is a principle from XP that encourages developers not to build features until they are absolutely necessary. This helps reduce complexity, prevents over-engineering, and ensures that development efforts are focused on delivering only what is needed.
Z
Zero Defects
Zero Defects is a quality assurance principle that aims to reduce defects as much as possible through practices like continuous testing, refactoring, and high-quality coding standards. While it may not be fully achievable, the philosophy encourages teams to strive for the highest possible quality.
