Inspiration
Our inspiration originated from a challenge we faced with our existing Advanced Issue Sync Service, which seamlessly syncs issues between two separate Jira instances. While the service effectively creates and updates issues on the target server based on changes from the source server, we identified a significant gap:
- Lack of Visual Indication: Users on the target server had no visual indication or context that an issue was created or updated through our sync service.
- Transparency Issues: This lack of transparency made it difficult for teams to track changes and understand the origin of updates, potentially leading to confusion or miscommunication.
We were motivated to enhance this experience by developing a solution that brings clarity and visibility to the synchronization process. Our idea was to create a plugin that:
- Detects Synced Issues: Identifies when an issue has been created or updated via our sync service.
- Displays Information Directly in Issue View: Adds a new panel within the issue view where users can immediately see that the issue is synchronized, providing confidence in the data they're working with.
But we didn't want to stop there. We recognized the value in not just showing that an issue was synced but also highlighting what was changed during the last update. Leveraging Rovo, Atlassian's powerful GenAI, we incorporated a feature that:
- Provides Quick Summary of Modified Fields: Offers a quick summary table of the fields that were modified.
- Enhances User Understanding: Allows users to swiftly grasp the nature of the updates without sifting through extensive change logs.
Participating in the hackathon presented the perfect opportunity to bring this solution to life. Utilizing Atlassian Forge and integrating Rovo aligns perfectly with the hackathon's objectives and categories.
Our project is driven by the desire to:
- Improve Transparency: Enhance clarity in the synchronization process.
- Enhance User Trust: Build confidence in the data users are working with.
- Streamline Collaboration: Facilitate better collaboration across teams using Jira.
By addressing a real-world problem with innovative tools, we're excited to contribute meaningful improvements to the Jira ecosystem.
What it does
Our solution is a Jira Cloud plugin designed to enhance visibility and transparency in issue synchronization between Jira instances. Here's how it works:
Key Features
Detection of Synced Issues
- The plugin automatically detects when an issue has been created or updated via our existing Jira issue synchronization service.
- It monitors incoming issues and updates to identify those originating from the sync process.
New Advanced Issue Sync Panel in Issue View
- Adds a dedicated panel within the Jira issue view.
- This panel displays critical information about the synchronization status, including:
- Sync Indicator: A clear marker showing that the issue is synced.
- Source Information: Details aabout the source Jira instance from which the issue was synced.
- Timestamp: The date and time of the last synchronization.
Field Change Summary with Rovo Integration
- Leverages Rovo, Atlassian's GenAI model, to analyze and summarize changes.
- Provides a quick summary table highlighting:
- Fields Changed: Lists all fields that were modified during the last sync.
- Change Details: Previous value and the new value.
- Enables users to understand updates at a glance without digging through extensive change logs.
Benefits
Enhanced Transparency
- Users can immediately see that an issue has been synced and understand its origin.
- Reduces confusion and improves trust in the data presented.
Improved Collaboration
- Teams across different Jira instances can coordinate more effectively.
- Shared visibility into changes promotes better communication.
Streamlined Workflow
- Quick access to change summaries saves time.
- Users can focus on their tasks without getting bogged down by administrative details.
How we built it
Leveraging our previous experience from past hackathons and our expertise in developing Atlassian plugins, we embarked on building a Jira Cloud plugin using Atlassian Forge. Our goal was to create a seamless integration that enhances visibility and transparency in issue synchronization between Jira instances.
Utilizing Atlassian Forge and REST APIs
- Atlassian Forge Platform: We chose Forge for its robust cloud app development capabilities, ensuring our plugin is secure, scalable, and well-integrated within the Jira ecosystem.
- REST APIs: We utilized the necessary Jira REST APIs to interact with issue data, enabling our plugin to detect when issues are created or updated via our synchronization service.
Integration with Jira Entity Properties
- Jira Entity Properties: To determine if a ticket was synced from our service and to track changes over time, we employed Jira entity properties.
- Custom Details: Both our plugin and the advanced issue sync service use these properties to store and access custom metadata.
- Change Tracking: By storing timestamps and sync identifiers, we can ascertain the extent of changes since the last synchronization.
Custom UI Module for Enhanced User Experience
- Custom UI Module: We utilized Forge's custom UI module to design a panel that is both intuitive and adaptable to future requirements.
- Look and Feel: The custom UI allows for a more personalized interface that aligns with Jira's design aesthetics.
- Future-Proofing: This approach ensures our plugin can accommodate additional features and custom UI enhancements down the line.
Integrating Rovo and Jira Automations for Intelligent Summaries
- Rovo AI Integration: To provide users with insightful summaries of changes, we integrated Rovo, Atlassian's new AI model.
- Field Change Detection: Rovo helps determine which fields were updated during the sync.
- Informative Panels: This information is displayed within the issue panel, offering users immediate insights without navigating away from the issue.
- Utilizing Jira Automations: Together with Rovo, we leveraged Jira Automations to enhance the functionality of our plugin.
- Automation Rules: We set up automation rules that trigger when issues are synchronized.
- Data Processing: These automations help process data and orchestrate the interaction between Rovo and our plugin.
- Seamless Integration: By using Jira Automations, we ensured that the AI-driven summaries are up-to-date and automatically generated whenever a synchronization occurs.
Enhancements to Our Advanced Issue Sync Service
- Minimal Service Updates: We performed slight modifications to our existing advanced issue sync service to enrich the integration.
- Adding Custom Details: By updating the service to include additional custom details in the Jira entity properties, we enhanced the plugin's ability to detect and display sync-related information.
- Note: While these changes extend beyond the plugin itself, they are crucial for deepening the integration and providing a cohesive user experience.
Challenges we ran into
During the development of our plugin, we encountered several challenges, particularly with integrating Rovo, Atlassian's AI model. While we could retrieve the necessary data directly from Jira's APIs, we aimed to leverage Rovo to enhance the user experience by providing intelligent summaries. This decision introduced a set of unique challenges:
Balancing API Data and Rovo Integration
- Data Redundancy: Since all the necessary information could be obtained directly from the Jira APIs, integrating Rovo risked duplicating data retrieval efforts.
- Challenge: Ensuring that Rovo added meaningful value beyond what was available from the APIs alone.
- Solution: We focused on utilizing Rovo to generate and insights that raw API data couldn't provide, thus enhancing the interpretability of the information.
Crafting Effective Prompts for Rovo
- Prompt Engineering: Creating effective prompts to elicit the desired responses from Rovo.
- Challenge: Formulating prompts that would yield useful, accurate, and concise summaries of the changes without overwhelming the user.
- Solution: We engaged in iterative testing of various prompt structures, refining them based on Rovo's responses to achieve the most informative results.
Triggering Rovo from Our Plugin
- Lack of Direct Integration Methods: Initially, we attempted to find an internal way within the plugin modules to trigger Rovo from our internal functions.
- Challenge: Despite searching through the documentation, we were unable to find a built-in method to invoke Rovo directly from the plugin's code.
- Solution: Since direct triggering wasn't feasible, we adopted a different approach by utilizing Jira Automations. This method allowed us to trigger Rovo indirectly, although it added some overhead to our solution.
Accomplishments that we're proud of
We are immensely proud of what we've achieved during this hackathon, especially considering the limited timeframe. Our key accomplishments include:
Enhancing Our Advanced Issue Sync Service with a Helper Plugin
- Introduction of Visual/UI Elements: By developing this helper plugin, we've significantly enhanced our existing Advanced Issue Sync Service. The plugin provides visual and user interface elements that were previously unavailable, offering users a more intuitive and informative experience.
- Empowering Users: The plugin empowers both new and existing users by providing clear insights into synchronized issues. This transparency helps users understand the synchronization process better, fostering trust and improving usability.
- Seamless Integration: The helper plugin integrates smoothly with our existing service, adding value without disrupting current workflows. This accomplishment bridges the gap between backend functionality and frontend user experience.
Achieving This Within the Hackathon Timeframe
- Rapid Development: Completing this project within the limited time of the hackathon is a testament to our team's dedication, efficiency, and technical expertise. It showcases our ability to quickly turn ideas into practical solutions.
- Creating a Lasting Tool: We're proud to have developed something that we will continue to use and build upon beyond the hackathon. Starting from this event, we've created a tool that adds real value to our service and benefits our users.
Leveraging Hackathon Resources Effectively
- Utilizing Atlassian Forge and Rovo: We effectively leveraged Atlassian Forge, Rovo, and Jira Automations to create a comprehensive solution that aligns with the hackathon's objectives.
- Enhancing User Experience: By integrating AI and automation, we added intelligent features that enhance the user experience, making complex data more accessible and actionable.
What we learned
Exploring Rovo, Atlassian's New AI Module
- Understanding Rovo's Capabilities and Limitations
- Learning: We delved into the functionalities of Rovo, Atlassian's new AI model, gaining a clear understanding of what it can and cannot do in its current state.
- Insights: Recognized that while Rovo offers powerful AI capabilities, it has limitations that require thoughtful integration to maximize its potential.
- Integrating Rovo with Plugins
- Learning: Discovered how to effectively integrate Rovo with our plugin despite the absence of direct methods in the documentation.
- Approach: Adopted alternative strategies, such as leveraging Jira Automations, to trigger Rovo and incorporate its outputs into our plugin.
Enhancing Prompt Engineering Skills
- Crafting Effective Prompts for AI
- Learning: Developed skills in prompt engineering to communicate effectively with Rovo, ensuring we received accurate and useful responses.
- Techniques: Experimented with different prompt structures and content to find the most effective ways to elicit the desired information from Rovo.
What's next for Advanced Issue Sync for Jira
While our plugin was initially developed for the hackathon, we are committed to fully integrating it with our existing Advanced Issue Sync service. We see immense potential in expanding its capabilities to provide even more value to our users. Here are the next steps we plan to undertake:
Implementing a Custom Advanced Issue Sync Changelog
- Enhanced Change Tracking: We plan to add a dedicated changelog that specifically records changes made by our sync service.
- Current Limitation: At present, the plugin only displays the latest update made by the service.
- Planned Improvement: By introducing a comprehensive changelog, users will have access to a detailed history of all synchronization activities.
- Benefits to Users:
- Greater Context: Users can see all changes over time, providing deeper insights into the synchronization process.
- Improved Auditing: Facilitates easier tracking and auditing of changes for compliance and reporting purposes.
Integrating Advanced Report Generation with Rovo
- Automated Weekly Reports:
- Confluence Integration: We aim to leverage Rovo to generate detailed reports and graphs, which will be compiled into a new Confluence page every week.
- Comprehensive Analytics: Reports may include metrics such as:
- Number of Tickets Synced: Total count of synchronized issues.
- Workflow Movements: Analysis of how many tickets moved between statuses (e.g., from "To Do" to "Done").
- Change Trends: Identifying patterns or trends in issue updates over time.
- Benefits to Users:
- Data-Driven Insights: Provides teams with actionable insights to improve their workflows.
- Enhanced Visibility: Stakeholders can easily access and review synchronization metrics without manual data compilation.
- Strategic Decision-Making: Supports better planning and resource allocation based on historical data.
Improving UI/UX and Enhancing Prompt Handling
- User Experience Improvements:
- Optimized Prompts: Enhance the way prompts and information are presented to handle larger responses effectively.
- Performance Optimization: Ensure that the plugin remains fast and responsive, even as it processes more data.
- Benefits to Users:
- Seamless Interaction: A smoother, more intuitive interface will make it easier for users to access and interpret information.
- Scalability: Improved handling of larger datasets ensures the plugin remains effective as user needs grow.
Expanding AI Capabilities with Rovo
- Advanced Data Interpretation:
- Natural Language Summaries: Utilize Rovo to generate more nuanced summaries of changes and trends.
- Predictive Insights: Explore the potential for Rovo to offer predictive analytics, such as forecasting potential bottlenecks or delays.
- Benefits to Users:
- Deeper Insights: AI-driven interpretations can reveal insights not immediately apparent from raw data.
- Proactive Management: Enables teams to address issues before they escalate, improving overall project efficiency.
Log in or sign up for Devpost to join the conversation.