Test And Accept
Concepts

Task Items

Organizing work into different types

Items are the building blocks that make up your Statements of Work. They let you organize work in different ways - as requirements, tasks, milestones, dependencies, or deliverables. Items can be nested to create detailed work breakdown structures.

What are Items?

Items help you:

  • Break Down Work: Decompose large projects into smaller, manageable pieces
  • Choose Your View: Look at work as requirements, tasks, or deliverables depending on what you need
  • Create Structure: Nest items under each other to show relationships
  • Track Dependencies: Identify work that's blocked by external factors
  • Mark Milestones: Highlight important dates and checkpoints

The Five Item Types

Requirements

What they are: High-level business or functional requirements that describe what the system needs to do.

Use requirements for:

  • User stories ("As a user, I want to...")
  • Feature specifications
  • Business rules
  • Functional requirements

Can contain: Other requirements, tasks, milestones, or deliverables Cannot contain: Dependencies

Example: "User Authentication System - The system must provide secure login with email/password and social media options"

Tasks

What they are: Specific, actionable work items that someone needs to complete.

Use tasks for:

  • Implementation work
  • Bug fixes
  • Code reviews
  • Technical tasks
  • Research spikes

Can contain: Other tasks (sub-tasks) Cannot contain: Requirements, milestones, dependencies, or deliverables

Example: "Implement login form component with email and password fields"

Milestones

What they are: Important dates, checkpoints, or phase completions in your project.

Use milestones for:

  • Release dates
  • Phase completions
  • Client review meetings
  • Demo dates
  • Key deadlines

Can contain: Requirements, tasks, dependencies, and deliverables Cannot contain: Other milestones (no nesting)

Special properties:

  • Target Date: When this milestone is due
  • Stakeholders: People who care about this milestone
  • Critical Path: Whether this is on the critical path
  • Risk Level: Low, medium, or high

Example: "Phase 1 Complete - All core features implemented and tested by Dec 31"

Dependencies

What they are: External blockers or things you're waiting for from third parties.

Use dependencies for:

  • Third-party API access
  • Vendor deliverables
  • External approvals
  • Infrastructure setup
  • License acquisitions

Can contain: Tasks (to help resolve the dependency) Cannot contain: Requirements, milestones, other dependencies, or deliverables

Special properties:

  • External Owner: Who is responsible (e.g., "Stripe", "AWS")
  • Contact Email: How to reach them
  • SLA Date: When they promised delivery
  • Escalation Date: When to escalate if not resolved
  • Risk Level: How critical this dependency is

Example: "Stripe API Credentials - Waiting for API keys from Stripe support team"

Deliverables

What they are: Client-facing outputs or artifacts that will be delivered.

Use deliverables for:

  • Documentation
  • Reports
  • Deployed features
  • Training materials
  • Design assets

Can contain: Requirements and tasks Cannot contain: Milestones, other deliverables, or dependencies

Special properties:

  • Client Visible: Whether the client can see this
  • Delivery Date: When it will be delivered
  • Approvers: Who needs to approve it
  • Delivery Method: How it will be delivered (email, portal, etc.)

Example: "User Documentation PDF - Complete user guide with screenshots"

Item Properties

Every item has:

Basic Properties

  • Title: A clear description of the work
  • Description: Detailed explanation (optional)
  • Type: Which of the five types it is
  • Parent: Which item it belongs under (optional)
  • Sort Order: Where it appears in lists
  • Level: How deep it's nested (0 = top level)
  • Created/Updated: Timestamps

Enhanced Task Properties (Optional)

Projects can enable additional task management features through project settings. When enabled, task items gain powerful tracking capabilities:

Task Dates

When Task Dates are enabled for a project:

  • Start Date: When work on this task begins
  • Due Date: When this task must be completed
  • Tasks with overdue dates are highlighted automatically
  • Use dates to plan timelines and track deadlines

Best for: Projects with strict timelines, client deliverables, or milestone tracking

Task Assignees

When Task Assignees are enabled for a project:

  • Assigned To: Which team member is responsible for this task
  • Assignees are selected from your project team members
  • Filter tasks by assignee to see workload distribution
  • Track who is responsible for each piece of work

Best for: Team projects, distributed work, or accountability tracking

Task Costs

When Task Costs are enabled for a project:

  • Estimated Cost: Expected cost to complete this task
  • Actual Cost: Real cost incurred
  • Currency is set at the project level (USD, EUR, GBP, etc.)
  • Compare estimated vs. actual to track budget accuracy

Best for: Client billing, budget tracking, or financial reporting

Task Status

All tasks have a status (always visible):

  • Not Started: Work hasn't begun yet
  • In Progress: Currently being worked on
  • Completed: Work is finished
  • Blocked: Cannot proceed due to dependencies or issues

Use status to track progress and identify blockers quickly.

Enabling Enhanced Properties

These features are controlled through Project Settings:

  1. Open your project settings
  2. Toggle the features you want to use:
    • Enable Task Dates
    • Enable Task Assignees
    • Enable Task Costs
  3. Set your currency (if using costs)
  4. Save settings

Once enabled, task forms will show the additional fields automatically. Existing tasks are unaffected - the new fields are optional.

Tiered Approach: Enable only what you need. Simple projects can use just basic task items, while complex projects can enable all features for full project management capabilities.

Hierarchy Rules

Items have strict rules about what can contain what:

✅ Allowed:

  • Requirement → Task
  • Requirement → Sub-Requirement
  • Milestone → Dependency
  • Deliverable → Task
  • Task → Sub-Task

❌ Not Allowed:

  • Task → Requirement (tasks can't contain requirements)
  • Milestone → Milestone (no nested milestones)
  • Dependency → Requirement

The application will prevent you from creating invalid structures.

Item Structure

Items form a tree inside your SOW:

Working with Items

Creating Items

When you create a new item, you'll choose:

  1. Type: Which kind of item (requirement, task, etc.)
  2. Title: A clear, descriptive name
  3. Description: Details about what needs to be done (optional)
  4. Parent: Whether it belongs under another item (optional)

For milestones, dependencies, and deliverables, you'll also provide their special properties.

Organizing Items

Nesting: You can nest items under each other to show relationships. For example:

  • A requirement can have multiple tasks underneath it
  • A task can have sub-tasks for more detail

Reordering: You can drag and drop items to change their order in the list.

Moving: You can move an item to a different parent, as long as the hierarchy rules allow it.

Item Prefixes

Many teams use prefixes to quickly identify item types:

  • REQ-001: User authentication
  • TASK-042: Create login API
  • MILE-003: Phase 1 complete
  • DEP-007: AWS account access
  • DELIV-002: User documentation

Best Practices

Choosing the Right Type

Use Requirements when: You're describing what needs to be built from a business perspective

Use Tasks when: You're describing specific work someone needs to do

Use Milestones when: You're marking an important date or checkpoint

Use Dependencies when: You're waiting on something external

Use Deliverables when: You're creating something for the client

Structuring Work

Keep it shallow: Try not to nest more than 2-3 levels deep

✅ Good:
Requirement
  ├─ Task 1
  ├─ Task 2
  └─ Task 3

❌ Too deep:
Requirement
  └─ Sub-Requirement
      └─ Task
          └─ Sub-Task
              └─ Sub-Sub-Task

Group related items: Keep items for the same feature together

One concern per item: Don't mix multiple unrelated features in one item

Naming Conventions

✅ Good names:

  • "User can log in with email and password"
  • "Create database schema for users table"
  • "Phase 1 development complete"
  • "Stripe API credentials received"
  • "API documentation PDF"

❌ Poor names:

  • "Login stuff"
  • "Do the thing"
  • "Milestone"
  • "Waiting"
  • "Docs"

Adding Criteria and Tests

Once you have your items (especially tasks), you'll add:

  1. Acceptance Criteria: Specific conditions that must be met for the item to be complete
  2. Tests: Ways to verify the criteria are satisfied

For example, for a task "Implement password reset":

Criteria might be:

  • User receives reset email within 1 minute
  • Reset link expires after 24 hours
  • User can set new password using the link

Tests verify each criterion:

  • Test that email arrives quickly
  • Test that old links don't work
  • Test that password actually changes

Tracking Progress

Items contribute to your SOW's overall completion:

  • Each item can be marked complete or incomplete
  • The SOW tracks what percentage of items are done
  • This counts for 40% of the overall SOW completion

You can see at a glance:

  • Total number of items
  • How many are complete
  • What still needs work

Item Lifecycle

  1. Creation: Add the item to your SOW
  2. Refinement: Add description, nest under parents, add criteria
  3. Execution: Mark as complete when work is done
  4. Verification: Check that all criteria are met
  5. Archiving: When the SOW is complete, items are archived with it

Tips for Managing Items

Keep Lists Manageable

  • Break large items into smaller ones
  • Aim for items that can be completed in a few days
  • Use parent/child relationships instead of huge descriptions

Use the Right View

  • Requirements view: See the big picture of what you're building
  • Tasks view: Focus on actionable work items
  • Milestones view: Track important dates
  • Dependencies view: See what's blocking you

Maintain Structure

  • Regularly review and reorganize items
  • Remove or archive obsolete items
  • Keep naming consistent
  • Update descriptions as you learn more

Common Patterns

Feature Development

When implementing a new feature:

  1. Create a Requirement for the overall feature
  2. Break it down into Tasks for implementation
  3. Add a Milestone for when it should be complete
  4. Note any Dependencies blocking progress
  5. Create a Deliverable for what gets shipped to the client

External Dependencies

When waiting on external parties:

  1. Create a Dependency item
  2. Fill in external owner and contact
  3. Set SLA and escalation dates
  4. Add Tasks underneath for follow-up actions
  5. Update risk level as needed