Skip to main content

Product

Who does product planning: Product owners build and prioritize the product backlog to maximize business value. Scrum masters facilitate backlog grooming and sprint planning sessions. Team members estimate work, break down stories into tasks, and provide technical input. Stakeholders submit requests and provide feedback on priorities.

Product planning focuses on building and managing a well-organized backlog that defines the work required to deliver value incrementally. Product owners identify features, get estimates from development teams, and prioritize work to maximize business value and minimize risk.

What Is Product Planning​

Product planning encompasses the activities product owners and teams use to define, organize, estimate, and prioritize the work that will be delivered. This includes managing backlog items (stories), defects, dependencies, goals, and all supporting artifacts that define product increments.

Effective product planning creates a shared understanding between product owners, stakeholders, and development teams about what needs to be built, why it matters, and in what order work should be completed.

Access Product Planning​

Navigate to product planning features through the main menu:

  1. Click the hamburger icon Hamburger icon > Product.
  2. Access specific planning areas from the Product menu.

Product Menu

Key Product Planning Areas​

Backlog Page Basics​

Navigate and use the backlog page effectively:

  • Access the backlog: Open and navigate backlog views for your projects
  • Filter backlog items: Find specific work using filters and search
  • Use tags: Organize and categorize work with tags for better visibility

The backlog page is your primary workspace for viewing, organizing, and managing all product work.

Managing Stories or Backlog Items​

Create and manage the stories that define your product features:

  • Add stories: Create new backlog items describing user needs
  • Edit stories: Update story details, acceptance criteria, and estimates
  • Split stories: Break large stories into smaller, deliverable pieces
  • Move stories: Transfer stories between projects as priorities shift
  • Close stories: Mark work as complete when acceptance criteria are met
  • Delete and recover: Remove stories or restore accidentally deleted items
  • View details: Access comprehensive story information including history and relationships

Stories capture user needs and desired functionality in a format teams can estimate and deliver.

Working with Defects​

Track and resolve quality issues throughout development:

  • Create defects: Log bugs and quality issues as they're discovered
  • Convert items: Change stories to defects when issues are found
  • Edit defects: Update severity, priority, and reproduction steps
  • Split defects: Break complex issues into manageable pieces
  • Track and report: Monitor defect trends and resolution rates
  • View defect details: Access full defect history and related information

Effective defect management ensures quality issues are tracked, prioritized, and resolved systematically.

Dependencies​

Identify and manage relationships between work items:

  • Add dependencies: Link related work items to track relationships
  • Track portfolio dependencies: Connect strategic portfolio items
  • Use Dependency Board: Visualize cross-team and cross-project dependencies
  • View dependencies: See all incoming and outgoing relationships
  • Track critical path: Monitor sequences that affect delivery timelines

Managing dependencies helps teams coordinate work and identify potential blockers early.

Backlog Goals or Objectives​

Group related work under measurable goals:

  • Create goals: Define objectives that organize related stories
  • Assign work items: Associate stories and defects with goals
  • Target goals: Set completion dates for goal delivery
  • Track progress: Monitor goal completion through metrics
  • Export goals: Share goal information with stakeholders
  • Close goals: Mark goals complete when objectives are achieved
  • Watch goals: Get notifications when goals change

Goals provide strategic context for backlog items and enable progress tracking against objectives.

Backlog Groups​

Organize related stories into logical collections:

  • Create backlog groups: Define collections of related work (formerly Feature Groups or Themes)
  • Assign stories: Associate stories with appropriate groups
  • Manage groups: Edit, close, or delete groups as needed
  • Report on groups: Track progress across grouped work
  • Reassign stories: Move stories between groups as priorities evolve
  • View group details: See all work and metrics for a group

Backlog groups help organize work around features, themes, or strategic initiatives.

Importing from Excel​

Bulk import backlog items and defects from spreadsheets:

  • Import work items: Add multiple stories, defects, or other assets at once
  • Update existing items: Refresh backlog data from Excel files
  • Handle status imports: Import item status when team processes are configured
  • Use column mappings: Match Excel columns to Digital.ai Agility fields

Excel import enables efficient bulk data entry and backlog initialization.

Ranking Work Items​

Prioritize work to maximize value delivery:

  • Drag and drop ranking: Reorder items visually in grids and boards
  • Rank by priority: Use priority values to sequence work
  • Rank numerically: Assign explicit rank numbers
  • Use action menu: Rank items through context menus
  • Apply WSJF: Use SAFe Weighted Shortest Job First prioritization

Effective ranking ensures teams work on the highest-value items first.

Regression Tests​

Maintain automated test suites for quality assurance:

  • Create regression tests: Define reusable automated tests
  • Organize tests: Group tests by area or feature
  • Move tests: Transfer tests between projects
  • Edit tests: Update test steps and expected results
  • Close tests: Mark obsolete tests as complete
  • Delete tests: Remove tests no longer needed

Regression tests ensure new changes don't break existing functionality.

Tracking Impediments with Issues​

Document and resolve blockers affecting progress:

  • Create issues: Log impediments, risks, and blockers
  • Block work items: Associate issues with affected stories or defects
  • Manage issues: Edit, copy, close, or delete issues
  • Generate work items: Convert issues into stories or defects
  • Move issues: Transfer issues between projects
  • Track resolution: Monitor issue status and resolution progress
  • Rank issues: Prioritize which impediments to address first

Issues provide visibility into obstacles that need removal to maintain flow.

Using Requests​

Capture stakeholder feedback and feature suggestions:

  • Add requests: Record feature ideas from stakeholders
  • Manage requests: Edit, copy, close, or delete requests
  • Generate work items: Convert approved requests into stories or defects
  • Rank requests: Prioritize which requests to implement
  • Export requests: Share request data with stakeholders
  • Track related assets: Monitor which requests became delivered features
  • Watch requests: Get notifications on request updates

Requests provide an intake mechanism for new ideas and stakeholder feedback.

Using Templates​

Create reusable patterns for common work items:

  • Create templates: Define reusable story, defect, or request patterns
  • Use templates: Generate new work items from templates
  • Add tasks and tests: Include standard tasks or tests in templates
  • Copy templates: Duplicate successful templates for reuse
  • Customize templates: Tailor templates to specific needs
  • Manage templates: Edit, move, or delete templates
  • Export templates: Share templates across projects

Templates ensure consistency and speed up creation of similar work items.

Product Planning Workflow​

  1. Build backlog: Create stories that describe user needs and desired functionality.
  2. Capture inputs: Add requests, defects, and feedback from stakeholders.
  3. Organize work: Group related items using goals, backlog groups, or tags.
  4. Manage dependencies: Identify relationships and coordinate across teams.
  5. Estimate work: Get team estimates for size and effort.
  6. Rank priorities: Order work by business value and strategic importance.
  7. Track progress: Monitor completion, velocity, and quality metrics.
  8. Refine continuously: Groom backlog regularly as new information emerges.

Available Reports​

Monitor product health and make data-driven decisions:

  • Backlog Group Roadmap: Visualize feature group timelines
  • Detail Roadmap: See comprehensive delivery schedules
  • Estimate Trend: Track estimation patterns over time
  • Parking Lot: View project status at a glance
  • Portfolio Item Bubble Chart: Compare items by multiple dimensions
  • Project/Release Roadmap: Plan release timelines
  • Request Trend: Monitor incoming requests
  • Velocity reports: Analyze delivery rates by various factors (date, priority, project, status, type, risk)
  • Workitem Cycle Time: Measure how long work takes to complete
  • Workitem Dependencies: Visualize relationship networks
  • Workitem Trend: Track work item creation and closure rates

Best Practices​

Keep backlog current: Review and update the backlog regularly to reflect changing priorities and new information.

Refine continuously: Schedule regular backlog refinement sessions to clarify stories, update estimates, and remove obsolete items.

Limit work in progress: Don't add items to sprints faster than teams can complete them to maintain sustainable pace.

Write clear acceptance criteria: Every story should have explicit, testable criteria for done to ensure shared understanding.

Break down large items: Split epics and large stories into smaller, deliverable increments that fit within sprints.

Prioritize ruthlessly: Not everything can be high priority; rank work objectively based on value, risk, and dependencies.

Estimate collaboratively: Involve the whole team in estimation to leverage diverse perspectives and build commitment.

Track dependencies early: Identify and manage cross-team dependencies before they become blockers.

Use templates for common patterns: Create templates for frequently used story types to maintain consistency and save time.

Group related work logically: Use backlog groups and goals to provide context and track progress toward strategic objectives.

Monitor velocity trends: Track team velocity over time to improve forecast accuracy and identify improvement opportunities.

Maintain quality focus: Balance new features with defect resolution to ensure sustainable product quality.

Success Indicators​

You're effectively managing your product backlog when:

  • Stories have clear acceptance criteria that teams understand
  • Backlog is prioritized by business value with top items ready for sprint planning
  • Dependencies are identified and managed proactively
  • Teams consistently deliver planned work within sprint capacity
  • Defect trends show decreasing creation rates and increasing resolution rates
  • Velocity is stable and predictable across sprints
  • Stakeholder requests are captured, prioritized, and transparently managed

Troubleshooting​

Why can't I create stories in my project?

You need modify access to the project. Contact your Project Admin to verify permissions. Some organizations restrict story creation to specific roles like Product Owner or Scrum Master.

Why don't my backlog items appear in the backlog page?

Verify that items are assigned to the correct project using the Project field. Check that filters aren't hiding items (clear all filters to see the full backlog). Ensure items aren't already assigned to sprints; the backlog page typically shows only unscheduled work.

Why can't I import from Excel?

Excel import requires properly formatted column headers matching Digital.ai Agility field names. See Import Column Reference for required formats. Verify you have modify access to the target project.

Why don't dependencies show on the Dependency Board?

Dependencies must be explicitly created using predecessor/successor relationships. Verify that dependency links are properly configured between work items. Check that the Dependency Board is filtered to show the correct projects and work items.