Organization
├── Site (e.g., yourcompany.atlassian.net)
│   ├── Project A (Scrum)
│   │   ├── Board
│   │   ├── Backlog
│   │   ├── Sprints
│   │   └── Releases
│   ├── Project B (Kanban)
│   │   ├── Board
│   │   └── Backlog
│   └── Project C (Team-managed)

# Find my open issues
assignee = currentUser() AND status != Done

# Sprint backlog
project = "PROJ" AND sprint in openSprints()

# Bugs created this week
project = "PROJ" AND issuetype = Bug AND created >= -7d

# Epics without stories
issuetype = Epic AND "Epic Link" is EMPTY

# High priority overdue
priority in (Critical, High) AND duedate < now() AND status != Done

# Issues changed status this week
status changed during (startOfWeek(), now())

# Issues in review for > 2 days
status = "In Review" AND status changed before -2d

# Unassigned issues in active sprint
assignee is EMPTY AND sprint in openSprints()

# Issues with no comments
issueFunction in commented("after -30d by any") ORDER BY created DESC

Backlog → To Do → In Progress → In Review → Done

Backlog → Sprint Backlog → In Progress → Code Review → QA → Done

When: Issue created
If: Assignee is empty
Then: Assign issue to reporter

When: Pull request merged
If: Issue linked to PR
Then: Transition issue to Done

When: Issue flagged
Then: Send Slack notification to #dev-alerts

Workspace
├── Space (e.g., Engineering)
│   ├── Folder (e.g., Product Development)
│   │   ├── List (e.g., Sprint 24.1)
│   │   │   ├── Task
│   │   │   │   └── Subtask
│   │   │   └── Task
│   │   └── List (e.g., Sprint 24.2)
│   └── Folder (e.g., Infrastructure)
└── Space (e.g., Marketing)

# Sprint field (Dropdown)
Sprint:
  - Backlog
  - Sprint 24.1
  - Sprint 24.2
  - Sprint 24.3

# Story Points (Number)
Story Points: 0, 1, 2, 3, 5, 8, 13, 21

# Priority (Dropdown with colors)
Priority:
  - Critical (Red)
  - High (Orange)
  - Medium (Yellow)
  - Low (Blue)

Trigger: Status changes to "Done"
Action:
  - Set due date to today
  - Notify watcher via comment

Trigger: Task created in "Bugs" list
Action:
  - Set priority to High
  - Assign to QA Lead
  - Add tag "needs-triage"

Trigger: Every Monday at 9 AM
Action: Create task "Weekly standup summary"
  - List: Team Rituals
  - Assignee: Team Lead
  - Due: Same day

## Description
[Describe the bug]

## Steps to Reproduce
1. Step 1
2. Step 2
3. Step 3

## Expected Behavior
[What should happen]

## Actual Behavior
[What actually happens]

## Environment
- OS:
- Browser:
- Version:

## Screenshots
[Attach if applicable]

Workspace
├── Team (e.g., Platform)
│   ├── Projects (time-boxed initiatives)
│   ├── Cycles (sprints)
│   └── Issues
│       ├── Sub-issues
│       └── Comments
└── Team (e.g., Mobile)

Triage → Backlog → Todo → In Progress → In Review → Done
                                            ↓
                                        Cancelled

Type:
  - bug
  - feature
  - improvement
  - chore
  - documentation

Area:
  - frontend
  - backend
  - infrastructure
  - design

Priority:
  - urgent
  - high
  - medium
  - low

# My team's active work
team = "Platform" AND status in (Todo, "In Progress", "In Review")

# Bugs to triage
label = "bug" AND status = Triage

# Blocked issues
status = Blocked

# Linear auto-detects these patterns
TEAM-123-feature-description
team-123/feature-description

Roadmap View:
├── Q1 2026
│   ├── Project: User Authentication
│   ├── Project: Payment System
│   └── Project: Mobile App
├── Q2 2026
│   └── Project: Analytics Dashboard
└── Backlog
    └── Project: AI Features

Organization
└── Project (e.g., Product Roadmap)
    ├── Views
    │   ├── Board (Status)
    │   ├── Table (All Fields)
    │   └── Roadmap (Timeline)
    ├── Fields
    │   ├── Status (Single select)
    │   ├── Priority (Single select)
    │   ├── Sprint (Iteration)
    │   └── Estimate (Number)
    └── Items (Issues, PRs, Draft issues)

# Status (Single select)
Status:
  - Backlog
  - Ready
  - In Progress
  - In Review
  - Done

# Priority (Single select)
Priority:
  - P0 - Critical
  - P1 - High
  - P2 - Medium
  - P3 - Low

# Sprint (Iteration)
Sprint:
  Duration: 2 weeks
  Start: Monday

# Estimate (Number)
# Use for story points: 1, 2, 3, 5, 8, 13

mutation {
  updateProjectV2ItemFieldValue(
    input: {
      projectId: "PROJECT_ID"
      itemId: "ITEM_ID"
      fieldId: "STATUS_FIELD_ID"
      value: {singleSelectOptionId: "DONE_OPTION_ID"}
    }
  ) {
    projectV2Item {
      id
    }
  }
}

name: Add issue to project
on:
  issues:
    types: [opened]

jobs:
  add-to-project:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/[email protected]
        with:
          project-url: https://github.com/orgs/ORG/projects/1
          github-token: ${{ secrets.ADD_TO_PROJECT_PAT }}

name: Set priority on bug
on:
  issues:
    types: [labeled]

jobs:
  set-priority:
    if: github.event.label.name == 'bug'
    runs-on: ubuntu-latest
    steps:
      - uses: titoportas/[email protected]
        with:
          project-url: https://github.com/orgs/ORG/projects/1
          github-token: ${{ secrets.GITHUB_TOKEN }}
          item-id: ${{ github.event.issue.node_id }}
          field-keys: Priority
          field-values: P1 - High

View: Kanban Board
Group by: Status
Sort by: Priority (descending)
Filter: is:open assignee:@me

View: Sprint Planning
Columns: Title, Status, Priority, Estimate, Sprint, Assignee
Sort by: Priority
Filter: sprint:current

View: Q1 Roadmap
Date field: Sprint (start/end)
Group by: Milestone
Zoom: Months

name: Bug Report
description: ""
labels: [bug, triage]
body:
  - type: textarea
    id: description
    attributes:
      label: Bug Description
      description: Clear description of the bug
    validations:
      required: true
  - type: textarea
    id: steps
    attributes:
      label: Steps to Reproduce
      value: |
        1. Go to '...'
        2. Click on '...'
        3. See error
  - type: dropdown
    id: priority
    attributes:
      label: Priority
      options:
        - Critical
        - High
        - Medium
        - Low

Group
├── Project A
│   ├── Issues
│   ├── Board (Project scope)
│   ├── Milestones
│   └── Labels
├── Project B
│   └── ...
└── Group Board (Cross-project)

workflow::backlog
workflow::ready
workflow::in-progress
workflow::review
workflow::done

priority::critical
priority::high
priority::medium
priority::low

type::feature
type::bug
type::chore

Milestone: v2.0.0
  Due date: 2026-03-01
  Issues:
    - Feature: User authentication
    - Feature: Payment integration
    - Bug: Login timeout issue

Milestone: Sprint 24.1
  Start: 2026-01-13
  Due: 2026-01-27
  Iteration cadence: Bi-weekly

Open → workflow::ready → workflow::in-progress → workflow::review → Closed

# Show only my issues
assignee_username = @me

# Current milestone
milestone = "Sprint 24.1"

# High priority bugs
label = priority::high AND label = type::bug

# In MR description
Closes #123
Fixes #456
Resolves #789

Related to #123
See #456

deploy:
  stage: deploy
  script:
    - deploy.sh
  environment:
    name: production
    url: https://app.example.com
    deployment_tier: production

# Auto-create issue on failure
on_failure:
  stage: notify
  script:
    - |
      curl --request POST \
        --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
        --data "title=Pipeline failed: $CI_PIPELINE_ID" \
        --data "labels=bug,pipeline-failure" \
        "$CI_API_V4_URL/projects/$CI_PROJECT_ID/issues"
  when: on_failure

Epic: User Authentication System
├── Feature: Login page
├── Feature: OAuth integration
├── Feature: Password reset
└── Feature: 2FA support

Agile: Epic → Feature → User Story → Task
Scrum: Epic → Feature → PBI → Task
CMMI:  Epic → Feature → Requirement → Task
Basic: Epic → Issue → Task

New → Active → Resolved → Closed
    → Approved → Committed → Done  (Scrum)

Work Item Type = Bug
AND State <> Closed
AND Assigned To = @Me
AND Area Path Under "Project\TeamA"

# Parent items
Work Item Type In (Epic, Feature)
AND State <> Done

# Child items (linked)
Work Item Type = User Story

# Find orphan stories (no parent)
Work Item Type = User Story
AND Link Type <> Parent

Project Settings → Boards → Project Configuration
└── Iterations
    ├── Sprint 1 (Jan 1-14)
    ├── Sprint 2 (Jan 15-28)
    └── Sprint 3 (Jan 29 - Feb 11)

Team Member: John
  Activity: Development
  Capacity: 6 hours/day
  Days off: Jan 10

Team Member: Jane
  Activity: Development
  Capacity: 8 hours/day
  Activity: Testing
  Capacity: 2 hours/day

# azure-pipelines.yml
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

steps:
  - task: UpdateWorkItem@1
    inputs:
      workItemId: '$(System.PullRequest.WorkItemId)'
      state: 'Active'
    condition: eq(variables['Build.Reason'], 'PullRequest')

Wiki
├── Home
├── Architecture
│   ├── System Overview
│   └── API Documentation
├── Development
│   ├── Getting Started
│   └── Coding Standards
└── Operations
    └── Runbooks

Workspace
├── Projects (Database)
│   └── Properties: Status, Owner, Timeline, Team
├── Tasks (Database)
│   └── Properties: Status, Project (Relation), Assignee, Due
├── Sprints (Database)
│   └── Properties: Start, End, Goal, Tasks (Relation)
└── Team (Database)
    └── Properties: Name, Role, Tasks (Relation)

Properties:
  - Name (Title)
  - Status (Select): Planning, Active, Complete, On Hold
  - Owner (Person)
  - Team (Multi-select)
  - Timeline (Date range)
  - Priority (Select): P0, P1, P2, P3
  - Tasks (Relation → Tasks)
  - Progress (Formula): Tasks complete / Total tasks

Properties:
  - Task (Title)
  - Status (Select): Backlog, Todo, In Progress, Review, Done
  - Project (Relation → Projects)
  - Sprint (Relation → Sprints)
  - Assignee (Person)
  - Due Date (Date)
  - Estimate (Number): Story points
  - Priority (Select)
  - Type (Select): Feature, Bug, Chore

# In Projects database
round(prop("Tasks Complete") / prop("Total Tasks") * 100)

dateBetween(prop("Due Date"), now(), "days")

if(prop("Priority") == "P0", 4,
  if(prop("Priority") == "P1", 3,
    if(prop("Priority") == "P2", 2, 1)))

# Meeting: [Title]
Date: [Date]
Attendees: [People]

## Agenda
- [ ] Item 1
- [ ] Item 2

## Notes


## Action Items
- [ ] @person: Task by [date]

## Decisions Made

# Sprint [Number]
Duration: [Start] - [End]

## Sprint Goal
[One sentence goal]

## Committed Items
[Linked tasks view filtered by Sprint = current]

## Capacity
| Team Member | Available Days | Capacity |
|-------------|----------------|----------|
| @person1    | 10             | 80 pts   |

## Risks
- Risk 1

Action: Create pages in Tasks database
Template: Task template
Properties:
  Sprint: Current sprint
  Status: Backlog

Action:
  1. Move incomplete tasks to next sprint
  2. Archive current sprint
  3. Create retrospective page

Board: Product Development
├── Lists
│   ├── Backlog
│   ├── To Do (This Sprint)
│   ├── In Progress
│   ├── Review
│   └── Done
├── Labels
│   ├── Bug (Red)
│   ├── Feature (Green)
│   ├── Improvement (Yellow)
│   └── Urgent (Orange)
└── Cards
    └── Card content, checklists, attachments

# Card Title
[Verb] + [Object] + [Context]
Example: "Implement user login with OAuth"

# Description
## Problem
What problem does this solve?

## Solution
High-level approach

## Acceptance Criteria
- [ ] Criterion 1
- [ ] Criterion 2

## Notes
Additional context

[ ] Design approved
[ ] Implementation complete
[ ] Tests written
[ ] Code reviewed
[ ] Documentation updated

Trigger: When a card is moved to list "Done"
Actions:
  - Mark due date complete
  - Remove all members
  - Add comment "@board Done!"

Trigger: Every day at 9:00 AM
Actions:
  - Move cards with due date in the past from "To Do" to "Overdue"
  - Sort "Backlog" by due date

Button: Start Working
Actions:
  - Move card to "In Progress"
  - Add me to card
  - Set due date to 3 days from now

Button: Create Sprint
Actions:
  - Create list "Sprint [date]"
  - Move top 10 cards from "Backlog" to new list

Fields:
  - Story Points (Number): 1, 2, 3, 5, 8, 13
  - Priority (Dropdown): Critical, High, Medium, Low
  - Sprint (Dropdown): Sprint 1, Sprint 2, Sprint 3
  - Assignee (Dropdown): Team members

1. Audit Source Data
   ├── Issue count
   ├── Custom fields
   ├── Attachments
   ├── Comments
   └── Links/relations

2. Map Data Model
   ├── Issue types → Work item types
   ├── Statuses → Statuses
   ├── Fields → Fields
   └── Users → Users

3. Test Migration
   └── Small subset first

4. Execute Migration
   └── Full data transfer

5. Validate
   ├── Data integrity
   ├── Link preservation
   └── User mapping

Mapping:
  Issue Types:
    Story → Issue
    Bug → Issue (label: bug)
    Epic → Project
    Task → Issue

  Statuses:
    To Do → Todo
    In Progress → In Progress
    In Review → In Review
    Done → Done

  Fields:
    Story Points → Estimate
    Sprint → Cycle
    Priority → Priority
    Labels → Labels

Mapping:
  Board → Space
  List → Status
  Card → Task
  Checklist → Subtasks
  Labels → Tags
  Due Date → Due Date
  Members → Assignees

Mapping:
  Project → Database
  Section → Status (property)
  Task → Page
  Subtask → Sub-page or Checkbox
  Tags → Multi-select
  Custom Fields → Properties

import requests
from requests.auth import HTTPBasicAuth

JIRA_URL = "https://your-domain.atlassian.net"
EMAIL = "[email protected]"
API_TOKEN = "your-api-token"

auth = HTTPBasicAuth(EMAIL, API_TOKEN)

# Export all issues
response = requests.get(
    f"{JIRA_URL}/rest/api/3/search",
    auth=auth,
    params={
        "jql": "project = PROJ",
        "maxResults": 100,
        "expand": "changelog,comments"
    }
)

issues = response.json()["issues"]

# Create issues in batches
BATCH_SIZE = 50
for i in range(0, len(issues), BATCH_SIZE):
    batch = issues[i:i + BATCH_SIZE]
    create_issues(batch)
    time.sleep(1)  # Rate limiting

# Create mapping table
old_to_new_ids = {}

for old_issue in old_issues:
    new_issue = create_issue(transform(old_issue))
    old_to_new_ids[old_issue.id] = new_issue.id

# Update links
for old_id, new_id in old_to_new_ids.items():
    update_links(new_id, old_to_new_ids)

                    Simple ←───────────────────→ Complex
                      │                              │
        Trello ───────┤                              │
                      │                              │
        ClickUp ──────┼───────────────────┐          │
                      │                   │          │
        Linear ───────┼───────────────────┤          │
                      │                   │          │
        GitHub ───────┼───────────────────┤          │
                      │                   │          │
        Notion ───────┼───────────────────┼──────────┤
                      │                   │          │
        GitLab ───────┼───────────────────┼──────────┤
                      │                   │          │
        Jira ─────────┼───────────────────┴──────────┤
                      │                              │
        Azure DevOps ─┼──────────────────────────────┤
                      │                              │
        Small Team    │                   Enterprise │

Preparation:
  - Backlog is prioritized (PO)
  - Stories have acceptance criteria
  - Stories are estimated
  - Team capacity calculated

1. Review sprint goal (5 min)
2. Team capacity check (10 min)
3. Select items from backlog (30 min)
4. Break down into tasks (60 min)
5. Confirm commitment (15 min)

Sprint Planning View:
  - Filter: project = PROJ AND sprint is EMPTY
  - Sort: Rank ascending
  - Visible fields: Key, Summary, Story Points, Priority

Sprint Board:
  - Quick filters: "Only My Issues", "Unassigned"
  - Swimlanes: By Assignee

Each team member:
1. What I completed yesterday
2. What I'm working on today
3. Any blockers

Walk the board (alternative):
1. Review "In Review" column
2. Review "In Progress" column
3. Review "To Do" for priorities

Standup Dashboard:
  Widgets:
    - Sprint Burndown
    - Active Sprint Items (by status)
    - Blocked Items
    - Items without estimates

Slack Bot Schedule: 9:00 AM daily
Questions:
  1. What did you accomplish yesterday?
  2. What will you work on today?
  3. Any blockers?
Post to: #team-standup

1. Sprint goal achievement (5 min)
2. Demo completed features (30-45 min)
3. Metrics review (10 min)
4. Stakeholder feedback (15 min)
5. Next sprint preview (10 min)

For each completed story:
- [ ] Feature name and user value
- [ ] Live demonstration
- [ ] Edge cases handled
- [ ] Questions from stakeholders

Start doing:
- [Team suggestions]

Stop doing:
- [Team suggestions]

Continue doing:
- [Team suggestions]

Liked:
- What went well

Learned:
- New insights

Lacked:
- Missing resources/support

Longed For:
- Wished we had

Mad (frustrated):
- [Issues]

Sad (disappointed):
- [Issues]

Glad (happy):
- [Positives]

Retrospective Database:
  Properties:
    - Sprint (Relation)
    - Category (Select): Start, Stop, Continue
    - Item (Title)
    - Action Owner (Person)
    - Status (Select): Open, Done

Template:
  - Section for each category
  - Voting enabled
  - Timer for timeboxing

1. Review upcoming priorities (10 min)
2. Discuss unclear stories (20 min)
3. Estimate stories (20 min)
4. Update acceptance criteria (10 min)

Story is ready when:
- [ ] Has clear acceptance criteria
- [ ] Is estimated
- [ ] Dependencies identified
- [ ] No open questions
- [ ] Small enough for one sprint

Monday:    Sprint Planning (Week 1)
           Backlog Refinement (Week 2)

Tuesday:   Standup
Wednesday: Standup
Thursday:  Standup
Friday:    Standup
           Sprint Review + Retro (Week 2)

Points
  │
30├──●
  │    ●─Ideal line
20├──────●
  │        ●
10├──────────●──Actual line
  │            ●
 0├──────────────●
  └─────────────────
  Day 1  5    10   14

Points
  │
40├        ▓▓▓▓▓
  │   ▓▓▓▓▓▓▓▓▓▓     ▓▓▓▓▓
30├───▓▓▓▓▓▓▓▓▓▓─────▓▓▓▓▓─── Average
  │   ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
20├   ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  │   ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
10├
  │
  └──────────────────────────
    S1  S2  S3  S4  S5  S6

Items
  │        Done ████████████████
50├       ██████████████████████
  │    Review ██████████████████
40├    ████████████████████████
  │  Progress ██████████████████
30├  ██████████████████████████
  │  To Do ████████████████████
20├  ██████████████████████████
  │  Backlog ██████████████████
10├
  │
  └──────────────────────────────
    Week 1    Week 2    Week 3

Layout: 2x3 grid

Row 1:
  - Sprint Burndown (50%)
  - Sprint Goal + Days Remaining (50%)

Row 2:
  - Sprint Backlog by Status (33%)
  - Blocked Items (33%)
  - Team Capacity (33%)

Row 3:
  - Items by Assignee (50%)
  - Story Points by Type (50%)

Layout: 2x2 grid

Row 1:
  - Release Burnup (50%)
  - Velocity Trend (50%)

Row 2:
  - Features by Status (50%)
  - Bug Trend (50%)

Layout: 3x2 grid

Row 1:
  - Velocity (last 6 sprints)
  - Escaped Defects

Row 2:
  - Cycle Time Distribution
  - PR Review Time

Row 3:
  - Team Availability
  - Action Items from Retros

Gadgets:
  - Sprint Burndown Chart
  - Sprint Health Gadget
  - Pie Chart (Issues by Status)
  - Filter Results (My Open Issues)
  - Two Dimensional Filter (Type vs Priority)

Metrics:
  - Completed issues trend
  - Cycle time by team
  - SLA compliance
  - Issue age distribution

Widgets:
  - Sprint progress bar
  - Time tracked vs estimated
  - Workload by member
  - Custom charts

# Week [N] Status Report

## Sprint Progress
- Sprint: [Name]
- Days remaining: [N]
- Velocity (target/actual): [X]/[Y] points

## Completed This Week
- [Item 1]
- [Item 2]

## In Progress
- [Item 1] - 80% complete
- [Item 2] - 50% complete

## Blockers
- [Blocker 1] - Owner: [Name], ETA: [Date]

## Risks
- [Risk 1] - Mitigation: [Plan]

## Next Week
- [Priority 1]
- [Priority 2]

# [Month] Metrics Report

## Velocity Trend
| Sprint | Committed | Completed | % |
|--------|-----------|-----------|---|
| S1     | 40        | 38        | 95% |
| S2     | 42        | 40        | 95% |
| S3     | 45        | 42        | 93% |

## Quality Metrics
- Bugs created: [N]
- Bugs resolved: [N]
- Escaped defects: [N]

## Cycle Time
- Average: [N] days
- P90: [N] days

## Team Highlights
- [Achievement 1]
- [Achievement 2]

## Areas for Improvement
- [Area 1]
- [Area 2]