Here are some labels that I have come up with for managing items in a project. They are in a yaml format so that they can be easily imported into a project management tool later.
functional_label_groups:
- Release:
- label: Dev
definition: The development phase of a software product, where new
features and changes are implemented.
use_when: You are actively developing new features or making changes to
the software.
example: Working on a new feature in the development branch of the code
repository.
- label: Test
definition: The process of evaluating a software product to identify
defects or issues.
use_when: You need to verify that the software meets the specified
requirements and is free of defects.
example: Running automated tests to check for bugs in a new feature.
- label: Alpha
definition: The first phase of testing a software product, typically
performed by the development team.
use_when: You need to test the software internally before releasing it to
external users.
example: Testing a new feature in a controlled environment before making
it available to customers.
- label: Beta
definition: The second phase of testing a software product, typically
performed by a select group of external users.
use_when: You need to gather feedback from real users before releasing the
software to the general public.
example: Inviting a group of customers to test a new version of the
- label: Integration
definition: The process of combining different components or systems to
work together as a whole.
use_when: You need to ensure that different parts of the software work
together correctly.
example: Integrating a new payment gateway with an existing e-commerce
platform.
- label: UAT
definition: User Acceptance Testing, where end users validate that the
software meets their needs and requirements.
use_when: You need to confirm that the software is ready for production
from the user's perspective.
example: Conducting a user acceptance test with a group of end users to
validate a new feature.
- label: Stage
definition: A pre-production environment that closely resembles the
production environment.
use_when: You need to test the software in an environment that mimics the
live system before deployment.
example: Deploying a new version of a web application to a staging server
for final testing before going live.
- label: Prod
definition: The live environment where the software is used by end users.
use_when: You are deploying the software to the live environment for
actual use.
example: Releasing a new version of a web application to all users in the
production environment.
human_label_groups:
- Release:
- label: Alpha
definition: The first phase of testing a software product, typically
performed by the development team.
use_when: You need to test the software internally before releasing it to
external users.
example: Testing a new feature in a controlled environment before making
it available to customers.
- label: Beta
definition: The second phase of testing a software product, typically
performed by a select group of external users.
use_when: You need to gather feedback from real users before releasing the
software to the general public.
example: Inviting a group of customers to test a new version of the
- label: Generally Available
definition: The final phase of releasing a software product, where it is
made available to the general public.
use_when: You are ready to release the software to all users after
completing testing and addressing any issues.
example: Publishing a new version of a mobile app to the app store for
download by all users.
- label: Release Management
definition: The process of planning, scheduling, and controlling the
release of a software product.
use_when: You need to coordinate the deployment of new versions or
updates
example: Creating a release plan, coordinating testing, and managing the
deployment process.
- label: Hotfix
definition: An urgent update to fix a critical issue in a software
product.
use_when: You need to address a severe bug or security vulnerability that
is impacting users.
example: Releasing a patch to resolve a data corruption issue that is
causing data loss for customers.
- label: Patch
definition: A minor update to fix bugs or add small enhancements to a
software product.
use_when: You need to address non-critical issues or make minor
improvements to the software.
example: Releasing a patch to improve the performance of a feature or fix
a minor display issue.
- label: Minor
definition: A small update to a software product that includes bug fixes,
minor enhancements, or performance improvements.
use_when: You are making incremental changes or improvements that do not
significantly impact the user experience.
example: Releasing a minor update to address a few minor bugs and improve
the performance of the software.
- label: Major
definition: A significant update to a software product that includes
substantial new features or changes.
use_when: You are introducing major changes or new functionality that
impact the user experience or require significant testing.
example: Releasing a major update that includes a redesigned user
- label: Service Pack
definition: A collection of updates, fixes, and enhancements for a
software product.
use_when: You need to deliver a set of updates or improvements to users
without releasing a new version of the software. (sp followed by a
version number)
example: Providing a service pack that includes security updates, bug
fixes, and new features for an operating system.
- label: <version>
definition: A specific version of a software product, typically
identified by a version number.
use_when: You need to refer to a specific version of the software for
documentation or support purposes.
example: Referring to simver version 2.3.1 or v1, v2, of a software
application in documentation.
- label: Release Candidate
definition: A version of a software product that is considered ready for
release pending final testing. (rc followed by a version number)
use_when: You need to perform one last round of testing before releasing
the software to the public.
example: Distributing a release candidate to a group of beta testers to
validate that it is stable and bug-free.
- label: Next
definition: The next version or iteration of a software product that is
currently in development. (next without a version number, version
needs planning).
use_when: You are working on the next release of the software and need to
track the progress of new features and changes.
example: Developing new features and enhancements for the next version of
a mobile app.
- Meta:
- label: Backlog Refinement
definition: The process of reviewing, prioritizing, and refining items
in the backlog.
use_when: You need to ensure that the backlog contains well-defined,
prioritized items that are ready for development.
example: Reviewing user stories, adding acceptance criteria, and
estimating effort for backlog items.
- label: Demonstration
definition: A meeting or presentation where the team showcases the
completed work to stakeholders.
use_when: You need to share progress, gather feedback, or demonstrate
the functionality of the software.
example: Presenting a new feature to stakeholders, showing how it works
and gathering feedback.
- label: Epic
definition: A large body of work that can be broken down into smaller
tasks or user stories.
use_when: You need to manage a complex project or feature that requires
multiple iterations or phases.
example: Developing a new product feature that involves multiple teams
and dependencies.
- label: Milestone
definition: A significant event or achievement in a project, often used
to mark progress or completion of a phase.
use_when: You need to track progress, set goals, or communicate key
achievements to stakeholders.
example: Reaching a milestone in the project plan, such as completing
the design phase or delivering a key feature.
- label: Sprint Review
definition: A meeting at the end of a sprint where the team demonstrates
the completed work to stakeholders.
use_when: You need to review the work completed in the sprint, gather
feedback, and plan the next steps.
example: Presenting the features developed in the sprint to stakeholders
and discussing the results.
- label: Story
definition: A unit of work that represents a user requirement or feature.
use_when: You need to define and track user requirements or features in
a project.
example: Writing user stories to capture the needs and expectations of
users for a new feature.
- label: Task
definition: A specific piece of work that needs to be completed as part
of a project. A task is a reasonable size that can be accomplished
without needing to subdivide. If it needs subdivision, then those
task should exist as subtasks of a story.
use_when: You need to break down work into smaller, manageable pieces
that can be assigned to team members, planned, reported on, and
delivered in a reasonable timeframe.
example: Creating tasks for developers to implement a specific features
or fix bugs as part of an effort.
- label: Presentation
definition: A formal talk or demonstration given to an audience.
use_when: You need to share information, present findings, or showcase
work to a group of people.
example: Giving a presentation on the project status, sharing key
findings, and discussing next steps.
- label: Project Retrospective
definition: A meeting where the team reflects on the project as a whole
and identifies lessons learned.
use_when: You need to review the project's performance, identify
successes and challenges, and capture lessons learned for future
projects.
- label: Kanban Retrospective
definition: A meeting where the team reflects on their work and
identifies opportunities for improvement.
use_when: You need to review the team's performance, identify
bottlenecks, and make process improvements.
example: Discussing what went well and what could be improved in the
team's workflow and processes.
example: Discussing what went well and what could be improved in the
project, and documenting key takeaways for future projects.
- label: Sprint Planning
definition: A meeting at the beginning of a sprint where the team plans
the work to be done.
use_when: You need to define the sprint goals, select user stories, and
estimate effort for the upcoming sprint.
example: Reviewing the backlog, selecting user stories for the sprint,
and creating a plan for the sprint's activities.
- Plan:
- label: Spike
definition: A time-boxed research activity.
use_when: You need to investigate a problem, gather information, or explore
a technology or solution to reduce uncertainty and inform future work.
example: Investigating the feasibility of a new technology or framework
before committing to its use in the project.
- label: Design
definition: Activities related to creating the blueprint or plan for the
system, component, or feature.
use_when: You need to create detailed designs, architecture diagrams, or
UI/UX designs before development begins.
example: Developing the architectural design for a new software module or
creating wireframes for a new user interface.
- label: Discovery
definition: An exploratory phase focused on understanding the problem,
defining requirements, and identifying potential solutions.
use_when: You need to understand the scope, gather requirements, or
validate ideas with stakeholders before moving into detailed design or
development.
example: Conducting user research to understand needs and pain points or
running workshops to gather requirements for a new feature.
- label: Planning
definition: Activities related to defining the scope, objectives, and
roadmap for the project.
use_when: You need to set up the project plan, including timelines,
milestones, and resource allocation.
example: Creating a project timeline and resource allocation plan.
- label: Stakeholder Engagement
definition: Activities focused on communication and collaboration with
stakeholders.
use_when: You need to involve stakeholders in decision-making, gather
feedback, or provide updates.
example: Conducting stakeholder meetings, sending status reports, or
gathering requirements.
- label: Risk Management
definition: Identifying, assessing, and mitigating risks that could impact
the project.
use_when: You need to proactively manage potential issues that could derail
the project.
example: Creating a risk register and developing mitigation plans for
identified risks.
- label: Procurement
definition: Activities related to acquiring goods, services, or resources
needed for the project.
use_when: You need to purchase, lease, or contract external resources or
services.
example: Sourcing software licenses, hiring contractors, or purchasing
materials.
- label: Retrospective
definition: A review process to evaluate what went well, what didn’t, and
how processes can be improved.
use_when: After completing a sprint, phase, or project to gather insights
and lessons learned.
example: Holding a meeting to discuss the outcomes of a sprint and identify
areas for improvement.
- label: Training
definition: Activities aimed at educating team members or end-users about
new systems, processes, or tools.
use_when: You need to ensure that individuals have the necessary skills and
knowledge to use or support the new solution.
example: Conducting training sessions or creating user manuals and
documentation.
- Monitor:
- label: Maintenance
definition: Ongoing activities to support, monitor, and improve the
delivered solution.
use_when: You need to provide post-deployment support, fix issues, and
perform regular updates or improvements.
example: Applying software patches, fixing bugs, or updating
documentation.
- label: Reliability
definition: The ability of a system to perform its functions under
specified conditions for a specified period of time.
use_when: You need to ensure that the system meets the required
performance and availability standards.
example: Monitoring system uptime, response times, and error rates to
ensure reliability.
- Code:
- label: Bugfix
definition: Correcting errors or defects in the code.
use_when: You need to address issues reported by users or identified
during testing.
example: Fixing a software bug that causes the application to crash.
- label: Enhancement
definition: Adding new features or improving existing functionality.
use_when: You need to extend the capabilities of the system or enhance
user experience.
example: Adding a new search feature or improving the performance of an
existing function.
- label: Refactor
definition: Restructuring code to improve readability, maintainability,
or performance without changing its external behavior.
use_when: You need to clean up the codebase, remove technical debt, or
optimize performance.
example: Rewriting a complex function to make it easier to understand or
extracting a reusable component from existing code.
- label: Feature
definition: A piece of functionality that delivers value to the user.
use_when: You are adding new capabilities or improvements to the system.
example: Implementing a new login screen, adding a payment gateway, or
integrating with a third-party service.
- label: Review
definition: A process of examining code changes to ensure quality,
consistency, and compliance with standards.
use_when: You need to ensure that code changes meet the project's
requirements and quality standards.
example: Conducting a peer code review to provide feedback on a
colleague's code changes.
- Build:
- label: Integration
definition: Combining different components or subsystems into a single
system.
use_when: You need to ensure that individual components work together as
intended.
example: Integrating a payment gateway with an e-commerce platform or
connecting a front-end application to a back-end API.
- Deploy:
- label: Deployment
definition: The process of delivering the completed product or feature to
the end-users or production environment.
use_when: You are ready to release the final product or increment to users.
example: Releasing a software update to production or launching a new
service.
- Debt:
- label: Debt
definition: Technical debt is the accumulated cost of additional work
created by choosing an easy but limited solution now instead of using
a better approach that would take longer.
use_when: You need to balance the need for quick delivery with the
long-term maintainability and scalability of the system.
example: Implementing a quick fix to meet a deadline that may require
refactoring later.
- Test:
- label: Funcitonal Testing
definition: Testing the system against the functional requirements to
ensure that it behaves as expected.
use_when: You need to verify that the system meets the specified
example: Testing a login form to ensure that users can authenticate
successfully.
- label: Release Testing
definition: Testing the system in a production-like environment to ensure
that it is ready for deployment.
use_when: You need to validate that the system works as expected in a
production environment.
example: Running performance tests on a staging server to simulate
production traffic.
- label: Systems Integration Testing
definition: Testing the interactions between different components or
systems to ensure that they work together correctly.
use_when: You need to verify that the system components communicate and
function as intended.
example: Testing the integration between a web application and a database
server.
- label: User Acceptance Testing
definition: Testing the system with end-users to ensure that it meets their
needs and expectations.
use_when: You need to validate that the system is user-friendly and
satisfies the requirements.
example: Having real users test a new feature to provide feedback on its
usability.