Jira integration

Overview AppFaktors provides seamless integration with Jira to bridge the gap between enterprise architecture planning and project execution. The integration enables bi-directional synchronization between AppFaktors Roadmap Kanban boards and Jira projects, allowing architecture teams to publish roadmaps directly to development teams while maintaining real-time status synchronization.

Integration Capabilities

Push to Jira (Export)

One-click export of AppFaktors Roadmap to Jira Project
Automatic project creation in Jira with structured task organization
Kanban board structure preservation maintaining workflow organization
Metadata mapping including priorities, labels, milestones, and due dates

⠀Pull from Jira (Sync)

Real-time status updates from Jira project back to AppFaktors Roadmap
Bi-directional synchronization keeping both systems current
Status mapping between Jira workflow states and AppFaktors roadmap stages
Progress tracking with automated updates based on Jira task completion

Architecture Workspace Integration

Roadmap Board Structure

The AppFaktors Roadmap Kanban board is organized into five key columns that map directly to Jira when exported:

1. Requirements

Purpose: Captures architecture requirements and specifications
Content: Functional and non-functional requirements, constraints, assumptions
Jira Mapping: Creates requirement-type issues or epics in Jira project

2. Recommendations

Purpose: Architecture recommendations and proposed solutions
Content: Technology choices, design patterns, implementation approaches
Jira Mapping: Becomes recommendation or story-type issues for review and approval

3. Risk Items

Purpose: Identified risks and mitigation strategies
Content: Technical risks, dependencies, potential blockers
Jira Mapping: Creates risk or task-type issues with appropriate priority levels

4. Controls

Purpose: Governance controls and compliance requirements
Content: Security controls, audit requirements, policy compliance
Jira Mapping: Becomes control or sub-task-type issues for implementation tracking

5. Technical Debts

Purpose: Architectural decisions and their rationale
Content: Technology selections, design choices, trade-off decisions
Jira Mapping: Creates debts or epic-type issues for documentation and tracking

Using the Jira Integration

Prerequisites

Before using the Jira integration, ensure: 1 Jira Access: Valid Jira account with project creation permissions 2 AppFaktors Configuration: Jira integration configured in AppFaktors settings 3 Project Setup: Architecture workspace and roadmap board prepared 4 Permissions: Appropriate permissions in both AppFaktors and Jira

Exporting Roadmap to Jira

Step 1: Prepare Your Roadmap

Navigate to your Architecture Workspace (e.g., "Boutique App 20")
Select the Roadmap tab to access the Kanban board
Ensure all roadmap items are properly categorized in the five columns
Review and complete item details including:
- Labels: For categorization and filtering
- Milestones: For timeline tracking
- Priorities: For task prioritization
- Due Dates: For scheduling

Step 2: Configure Export Settings

Click the "Export to DevOps Project" button in the top-right corner
Configure export parameters:
- Target Jira Instance: Select or configure Jira connection
- Project Settings: Define new project name and key
- Issue Type Mapping: Map AppFaktors columns to Jira issue types
- Field Mapping: Configure custom field mappings if needed

Step 3: Execute Export

Review export summary and mappings
Click "Push to Jira" to initiate the export process
Monitor export progress and status
Verify successful project creation in Jira

Managing Ongoing Synchronization

Automatic Status Updates Once exported, AppFaktors automatically synchronizes with the Jira project:

Real-time Sync: Status changes in Jira are reflected in AppFaktors
Progress Tracking: Roadmap items update based on Jira task completion
Workflow Mapping: Jira workflow states map to AppFaktors roadmap columns

Manual Synchronization

Refresh Status: Use the sync button to manually trigger status updates
Conflict Resolution: Handle conflicts when items are modified in both systems
Selective Sync: Choose which items to synchronize based on filters

Filtering and Organization

Available Filters

The Roadmap board provides comprehensive filtering options: Member Filters

All Members: View all assigned team members
Specific Members: Filter by individual contributors
Unassigned: Items without assigned owners

⠀Label Filters

All Labels: View all labeled items
Specific Labels: Filter by categories, components, or custom tags
Unlabeled: Items without classification

⠀Milestone Filters

All Milestones: View items across all milestones
Specific Milestones: Focus on particular release or timeline targets
No Milestone: Items not associated with specific milestones

⠀Priority Filters

All Priorities: View items regardless of priority
High Priority: Focus on critical items
Medium/Low Priority: Review less critical items

⠀Due Date Management

Ongoing Tasks Toggle: Show/hide tasks currently in progress
Date-based Filtering: Filter by specific due date ranges
Overdue Items: Identify items past their due dates

⠀Search Functionality

Name Search: Quick search by roadmap item name or title
Real-time Results: Instant filtering as you type
Combined Filters: Use multiple filters simultaneously for precise views

Best Practices

Roadmap Organization

Before Export

Complete Item Details: Ensure all roadmap items have proper descriptions, priorities, and assignments
Logical Grouping: Organize items logically within each column
Dependency Mapping: Identify and document inter-item dependencies
Timeline Validation: Verify due dates and milestone assignments

Column Management

Requirements: Include detailed acceptance criteria and specifications
Recommendations: Provide clear rationale and implementation guidance
Risk Items: Include mitigation strategies and impact assessments
Controls: Specify compliance requirements and validation criteria
Technical Decisions: Document decision rationale and alternatives considered

Jira Project Management After Export

Project Configuration: Configure Jira project settings, workflows, and permissions
Team Assignment: Assign appropriate team members to exported issues
Sprint Planning: Organize exported items into development sprints
Progress Monitoring: Regularly review synchronization status

Ongoing Maintenance

Status Updates: Keep Jira issues current to maintain AppFaktors synchronization
Comment Synchronization: Important updates should be reflected in both systems
Scope Changes: Coordinate changes between architecture and development teams

Integration Governance Data Consistency

Single Source of Truth: Establish clear ownership for different types of updates
Change Management: Define processes for handling conflicting updates
Regular Reviews: Periodic validation of synchronization accuracy

Access Control

Permission Alignment: Ensure consistent access controls between systems
Role-based Access: Map AppFaktors roles to appropriate Jira permissions
Security Compliance: Maintain security standards across both platforms

Troubleshooting

Common Issues

Export Problems

Permission Errors: Verify Jira project creation permissions
Connection Issues: Check Jira instance connectivity and authentication

⠀Synchronization Issues

Status Lag: Allow time for synchronization or trigger manual refresh
Data Conflicts: Resolve items modified in both systems simultaneously

Benefits and Value

For Architecture Teams

Seamless Handoff: Direct transfer of architecture decisions to development teams
Progress Visibility: Real-time view of implementation progress
Reduced Manual Work: Automated synchronization eliminates manual status updates

For Development Teams

Clear Requirements: Structured requirements and recommendations from architecture
Context Preservation: Maintains architectural context throughout development
Integrated Workflow: Works within existing Jira-based development processes

For Organizations

Improved Alignment: Better alignment between architecture planning and execution
Enhanced Traceability: Clear traceability from architecture decisions to implementation
Faster Delivery: Reduced friction between planning and execution phases

Conclusion

The AppFaktors Jira integration provides a powerful bridge between enterprise architecture planning and project execution. By enabling one-click export of roadmaps and bi-directional synchronization, teams can maintain alignment while working in their preferred tools. Following the best practices outlined in this guide will help maximize the value of this integration and ensure successful project delivery.