Rally - Jira Integration

Integrating best-of-breed tools like Rally and Jira eliminates collaboration barriers and helps product managers, developers and quality assurance teams achieve enhanced transparency and end-to-end visibility. Watch the video to know how a bidirectional integration using OpsHub Integration Manager (OIM) breaks down information silos, empowering teams to make data-driven, informed decisions to deliver quality products faster.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

Businesses achieving agile transformations on a small scale often fail to replicate their success at an enterprise level due to a lack of alignment across disparate systems and cross-functional teams. Adopting an automated integration solution increases collaboration, reduces development time, and ensures quicker time to market.

Integrating best-of-breed tools like Rally and Jira using OpsHub Integration Manager (OIM) provides full visibility to product management, development, and quality assurance teams into each other’s work. This seamless integration enables faster product delivery and delivers cohesive value to customers.

The product team in Rally starts by creating user stories, which synchronize as stories in Jira. They assign each story a name, description, status (e.g., “active”), and priority, saving them accordingly. Additional user stories can also be created and prioritized differently based on requirements. All user stories created in Rally automatically synchronize to Jira along with their details, such as name, description, Remote Entity ID, and Remote Entity Link. Statuses and priorities set in Rally are mirrored in Jira.

The development team begins work on a user story in Jira by changing its status to “in progress,” adding comments and attachments, and saving their updates. These changes are bidirectionally synchronized with the corresponding Rally user story. For example, a status change to “in progress,” added attachments, and comments in Jira reflect accurately in Rally, along with the Remote Link and Remote ID for the Jira entity.

Similarly, updates made in Rally, such as modifications to a user story’s description or status, are synchronized back to Jira. The development team can also link a defect to a user story, create bugs with appropriate summaries and descriptions, set priorities, and specify link types. These defects synchronize to Rally, maintaining the linkage to the relevant user stories.

The product team in Rally can further enhance defect details by adding attachments, comments, and modifying statuses, such as setting it to “submitted.” Any updates to the defect in Rally, including priority changes or additional information, synchronize seamlessly to Jira. Entity IDs and links for the defect are visible in both tools, ensuring transparency and alignment between the teams.

This bidirectional synchronization ensures that updates made in Jira and Rally are consistently reflected, maintaining collaboration and reducing inefficiencies across the product development lifecycle.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

ServiceNow - Rally Integration

Cross-team visibility and enhanced traceability between systems are critical for organizations to deliver high-quality software at a competitive pace. Watch how the customer support team using ServiceNow and the development team using Rally benefit from complete transparency into each other’s work eliminating communication hurdles, quality issues, and manual errors.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

Lack of traceability in an enterprise toolchain impacts product standards and delivery schedules, causing a decline in business growth and profitability. Additionally, different workflows for cross-functional teams make collaboration challenging, leading to longer resolution times and unhappy customers. An automated integration between ServiceNow and Rally using OpsHub Integration Manager (OIM) provides real-time visibility for customer support and development teams into each other’s work, eliminating communication hurdles, quality issues, and manual errors.

Let’s take a look at a bidirectional sync between the two systems. In this demo, two teams are working in ServiceNow: the Software team and the Network team. Problems are created in ServiceNow with descriptions, priority, state, assignment groups, comments, work notes, and other relevant fields. These problems are assigned to either the software or network team based on their nature, and the appropriate Rally project is selected accordingly. For example, problems under the Software assignment group are synchronized with the Software project in Rally, while problems under the Network assignment group are synchronized with the Network project.

In Rally, these problems appear as defects under the respective Software and Network groups, complete with all the details like descriptions, status, and more. Both comments and work notes from ServiceNow sync to the discussion section of the corresponding Rally defect, ensuring all information is captured.

The network development team works on the defects logged in Rally, updating fields, adding attachments, and changing statuses as progress is made. These updates automatically sync back to ServiceNow, allowing the customer support team to view the changes in real time. Comments added in Rally’s discussion section are bidirectionally synchronized with ServiceNow. Similarly, edits to defects in Rally reflect in ServiceNow, and updates made in ServiceNow sync back to Rally.

Meanwhile, the software team in Rally updates defect details as work progresses. These updates are reflected in the corresponding problems in ServiceNow. Changes made by either team are visible in both systems, ensuring seamless collaboration and real-time visibility for all stakeholders.

This concludes the demo. Thank you for watching!

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Sync diagrams and traceability | Aras Innovator Integration with Enterprise Architect

Continuous product development demands end-to-end traceability throughout the product lifecycle. Streamline your product lifecycle management with seamless integration between Aras Innovator and Enterprise Architect. This demo showcases how Aras software integration, powered by OpsHub Integration Manager (OIM), creates a robust digital thread, connecting best-of-breed tools for enhanced collaboration. Experience automated, bidirectional data synchronization between product managers using Aras Innovator and systems architects working in Enterprise Architect.  

This near real-time information exchange ensures complete traceability and visibility across the entire product lifecycle, from concept and design through manufacturing, quality control, and even disposal. This PLM Aras integration eliminates manual intervention, guaranteeing 100% accurate and reliable data transfer. This empowers modern teams to accelerate digital transformation and optimize product development with the best product lifecycle management tools. 

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

Product managers and systems architects need complete visibility into their delivery chain to produce quality products without relying on manual workarounds. The integration between Aras and Enterprise Architect (EA) using OpsHub Integration Manager (OIM) provides these stakeholders with rich traceability and enhanced transparency, boosting productivity for each team.

This bidirectional integration automatically synchronizes requirements, ensuring end-to-end visibility into all historical and current data for each user with full context in real time. This enables teams to make independent decisions based on the complete context of the data present within the ecosystem.

Let’s see how this works. The systems Architect begins by creating an element in Enterprise Architect, assigning it a name, and saving it. He proceeds to add priorities, leaves the status as “Proposed,” and provides a description. OpsHub Integration Manager supports rich text formatting, including bold, underline, italics, subscript, superscript, and more. For example, the description added in bold and bullet points will sync to Aras with the same formatting.

The systems architect updates the priority of the element from “Medium” to “High” and saves it. In this demo, the polling interval for OIM is set to one minute, so the Element and all its properties automatically synchronize to Aras. Navigating to Aras, the element is reflected as a requirement with all details, including the title, status, priority, remote ID, type, and the rich-text-formatted description.

Next, the product manager in Aras makes changes to the description, updates the status to “Approved,” lowers the priority to “Medium”, and saves the updates. These revisions bidirectionally sync back to Enterprise Architect.

Back in EA, the systems architect refreshes the page to see the updated element details. The revised description, including the third bullet point added in Aras, is visible under Notes. Under Tags, the remote ID of the Aras requirement and its remote link are displayed. In the Elements view, the updated status (“Approved”) and priority (“Medium”) are reflected.

This completes the demo. Thank you for watching!

IBM DOORS – PTC’s codebeamer Migration

Modernizing requirements management tool becomes a business imperative as product complexity grows and teams expect a modern, agile and feature-rich user experience. However, migration projects can be tricky owing to the vast amounts of legacy data and the need to deliver value throughout the migration. Traditional approaches to tool migration such as Big Bang may not be the right option considering the downtime and disruption implications. Watch this migration demo to learn how to migrate data using two effective strategies – Rip and Replace and Coexist – using IBM DOORS (a legacy tool) and PTC’s codebeamer (a modern tool). With OpsHub’s migration tool, both strategies can be implemented without data loss, downtime, or disruption.

Experience scalable, non-disruptive migration with OMM

Schedule a free 30-minute live demo with our migration experts

Video Transcript

In today’s demo, both the “Rip & Replace” strategy, and the “Coexist” strategy will be demonstrated. First, the Rip and Replace strategy will be shown by migrating data from the legacy tool, IBM DOORS, to PTC’s Codebeamer. While the data migration occurs, updates will be made to DOORS requirements and see how these changes are also migrated to Codebeamer.

After the migration demo, the Coexist strategy will be demonstrated. In this part, changes will be made in Codebeamer to show how data can coexist in both Codebeamer and DOORS, enabling teams to work seamlessly across both tools.

On the screen is Codebeamer, which currently has no requirements and is an empty project, and DOORS, which has around 20 requirements. A variety of data combinations have been created, including a parent-child hierarchy. Some requirements contain complex data like images, xlxs file, and other attachments.

The migration has already been pre-configured. Once triggered, the migration interface will be closed, and the focus will be on interacting with Codebeamer and DOORS in the background while the migration tool transfers data from DOORS to Codebeamer.

Refreshing the page, the migration is progressing, and the hierarchy of requirements from DOORS is being replicated in Codebeamer. The images and other data have been successfully migrated.

For legacy tool users migrating to Codebeamer, there will be no loss of data. All data from the legacy tool is visible in Codebeamer, enabling users to work with the same dataset in a more modern tool.

After another refresh, more requirements appear. The first requirement can now be opened, with the title, assigned user, and other details exactly as they were in DOORS. Users can also sync the DOORS requirement ID in the fields if needed.

The description and attachments have been successfully migrated. After a final refresh, all requirements are visible in Codebeamer, with all rich text data, including tables and bullet points, preserved.

Next, an update will be made to one of the requirements in DOORS. “Code Review and User Testing” will have its description changed to “Functional design review is required.” After saving, the migration tool will automatically detect the change in the background and bring it over to Codebeamer.

Refreshing Codebeamer, the updated description is now reflected for the same requirement.

The Codebeamer team will now change the status to “Waiting for Approval” and update the description accordingly. After saving, the Coexist strategy is now in place. The data from the legacy tool has been migrated into Codebeamer, but both tools are still in use, ensuring that users work on the latest data regardless of the platform.

Finally, the updates can be checked in DOORS. The “Waiting for Approval” description has been added, and the status has been updated to “In Progress,” as configured by the migration tool. The status mapping ensures that “Waiting for Approval” in Codebeamer corresponds to “In Progress” in DOORS.

As demonstrated, organizations can choose between the Rip & Replace or Coexist strategy, depending on their needs. Both strategies are supported by the OpsHub migration tool, ensuring no data loss during the migration process.

Experience scalable, non-disruptive migration with OMM

Schedule a free 30-minute live demo with our migration experts

Jama Connect & Enterprise Architect Integration

Digital transformation relies on a continuous flow of information throughout the product lifecycle. Enterprise Architect integration plays a crucial role by enabling organizations to trace high-level specifications across all stages of development: analysis, design, implementation, testing, and maintenance. Jama Connect integration further enhances the foundation by effectively managing and tracing requirements from initial stakeholders to final product delivery.
This traceability ensures digital continuity throughout the product lifecycle, fostering a robust digital thread – a game changer for digital transformation. In this Jama Connect and Enterprise Architect integration video, discover how system engineers and product managers gain automatic access to cross-functional data, both historical and real-time within their preferred tool, all without any manual intervention.
OpsHub Integration Manager (OIM) facilitates seamless integration between visual modelling and requirements management tools, empowering development teams to design and build software and systems with higher accuracy while eliminating the need for tedious manual workarounds.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

Emerging technologies are driving product innovation across various sectors, particularly in the automotive industry. While standard frameworks define, implement, and evaluate the processes required for system development, the automotive sector also requires effective communication and cross-team visibility to deliver quality products and achieve positive business outcomes.

Integrations powered by OpsHub Integration Manager (OIM) enable organizations to manage customer requirements and address product complexity through enhanced collaboration. In this video, we demonstrate how OIM integrates Enterprise Architect (EA) and Jama Connect bidirectionally. This integration allows system engineers and product managers to access both historical and real-time cross-functional data in their preferred systems with full context. The traceability between visual modeling and requirements management tools empowers development teams to design and build software and systems accurately, avoiding tedious manual workarounds.

In Jama, a component named “EA Demo” is created, containing two pre-configured sets: one for storing requirements and the other for diagrams. The product manager begins by creating a requirement in Jama, adding details such as name, description, and priority. Fields mapped in OIM’s configuration, including custom fields, automatically synchronize back to Enterprise Architect. For instance, the product manager assigns an EA element type of “Activity” to the first requirement, ensuring it synchronizes to EA as an Activity element. Additional requirements are added with EA types such as Action, Block, and Interface.

Once the requirements are created in Jama, linkages between them can be established. For example, the product manager relates the “Activity” requirement to the “Action” requirement, selects the relationship type, and saves it. The relationship is successfully created in Jama, showing “Activity” as a downstream item of “Action” and vice versa.

In Enterprise Architect, the Systems Architect refreshes the page to view all synchronized elements from Jama. Each element reflects its custom EA type, along with associated details like name, description, and type. Using these elements, the systems architect creates diagrams. For instance, an activity diagram visualizes the established linkage between “Activity” and “Action.” Additional elements, such as new actions and activities, can also be added, related, and synchronized back to Jama.

The systems architect then creates a block definition diagram, incorporating elements synchronized from Jama, such as “Block 1” and “Interface,” alongside native EA elements like an Actor. Relationships are established between these elements, and all updates synchronize back to Jama. Similarly, a sequence diagram is created using native EA elements, and once completed, diagrams are renamed according to their type.

In JAMA, the product manager reviews the synchronized diagrams. The sequence diagram and all its associated details, including name and type, are visible. The block diagram reflects the elements and relationships synchronized from EA. In the activity diagram, all elements and their linkages, initially created in Jama and used in the EA diagram, are displayed. The remote ID field in Jama provides a link to the corresponding EA element ID, while in EA, each requirement reflects the associated Jama ID and link.

This seamless bidirectional integration ensures that teams across systems have complete visibility into design elements, relationships, and requirements, enhancing collaboration and productivity.

That concludes the demo. Thank you for watching!

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

SAML Login Server Configuration

Security Assertion Markup Language (SAML) is an open standard used for authentication. It passes information about users, logins, and attributes between the identity provider and service provider. OpsHub Integration Manager (OIM) supports SAML authentication so users can log in with their SAML credentials. As a result, SAML authentication improves a user’s experience, increases security and reduces costs for service providers. In addition, with SAML, users can avoid hassles associated with maintaining account information across multiple servers. In this video, let’s look at how users can log into OIM by SAML without typing in their ID and password.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

Security Assertion Markup Language (SAML) is an open standard used for authentication. OpsHub Integration Manager (OIM) supports SAML authentication, enabling users to log in using their own SAML credentials.

Let’s take a look at how SAML login server can be configured. In this video, we are using Okta as the login server, which is similar to Microsoft’s SAML login server. OpsHub users can also use other login servers which support similar functionalities.

The process begins with the user navigating to “Applications” in Okta to create a new SAML login application. Under General Settings, the user provides an application name and any additional information, if needed.

Next, under the “Configure SAML” section, the user enters the Single Sign-On (SSO) URL and Audience URI, as specified in the OpsHub documentation. Once these details are entered, the user clicks “Finish.”

With the setup complete, the user navigates to the Sign-On page in Okta to copy the Identity Provider metadata URL, which will be used to configure the SAML login server in OpsHub.

After signing into OpsHub Integration Manager, the user goes to “Administration” and selects “Login Server Management” to configure a new SAML login server. Here, the user provides a server name and pastes the Identity Provider metadata URL copied earlier.

Before saving the SAML login server configuration, the user ensures the “Test Connection Before Adding Server” toggle is enabled. The “Test Server Connection” option is then used to verify the details, and the configuration is saved.

Once the SAML configuration is complete, the user proceeds to “User Management” to create a user for SAML login. Along with mandatory inputs like name and username, the newly created SAML server details are provided.

The same user created in OIM will now have to get added in the Okta app as shown in the video. Finally, back in OpsHub Integration Manager, the user activates the SAML login server.

Let’s now see how users can log into OpsHub via SAML without needing to manually enter their ID and password.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

How to Integrate IBM Rational DOORS and Verisium Manager

This video explores the powerful IBM Rational DOORS integration with Verisium Manager (formerly Cadence vManager), which connects your requirements, design, and verification data across the entire product lifecycle. This integration creates a robust digital thread, essential for driving digital transformation. With IBM Rational DOORS Next Generation, modules automatically synchronize with Verisium Manager, preserving all attributes and hierarchy within the sections, ensuring seamless data flow.  

OpsHub Integration Manager (OIM), an enterprise-grade tool, simplifies the integration of best-in-class requirements management tools like DOORS by automating data synchronization with zero manual intervention. It effortlessly handles large data volumes, ensuring scalability as your projects and teams expand. This integration is a key solution for teams looking to leverage the power of IBM tools for efficient and scalable requirements management. 

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

In the DOORS database, we can see a project and some modules. We will use the Verification Requirements module and Verification Tests module in DOORS for this demonstration. Objects under the verification requirements will sync to vManager as sections or subsections, and test cases and metric ports attached in vManager linked with the sections or subsections will synchronize back as objects inside the verification test module.

In the Verification Requirements module, we have predefined requirements. We can see a hierarchy of the requirements here, along with their respective attributes like priority, status, heading, short text, etc. The verification test module is currently empty in vManager. Currently, V Plan is also empty, as requirements from DOORS haven’t synchronized yet as sections or subsections.

Now, we will start with synchronizing the verification requirements. OpsHub will preserve the history of DOORS requirements while syncing them to vManager as sections. The OpsHub admin is activating the requirement synchronization. All the objects from the Verification Requirements module in DOORS will synchronize to vManager as sections and subsections, preserving all the attributes and hierarchy. In vManager, the verification engineer refreshes the page and views the four sections and subsections that have been created.

All attributes for each section and subsection, like the title, description, status, priority (mapped as severity), remote ID of the DOORS object in the custom field, and the remote link to navigate to the DOORS object, have successfully synchronized from DOORS to vManager, maintaining the hierarchy. In DOORS, a field is called an attribute. We can see the linked ID of the section from vManager. In all the objects, the value is set, helping users achieve better traceability when navigating to vManager.

Navigating to vManager, the verification engineer now starts adding test cases. Under the first test case, they add a name, description, test execution status, and severity. Similarly, another test case is added. Here, we can see the section and subsection levels with a red flag, whereas the test cases added do not reflect the red flag. This is because the test cases were last updated on vManager. To clear the flag, follow the steps as shown in the video. The flags are no longer visible, indicating that the value has been read and accepted by the verification team.

The verification engineer now goes ahead and adds metrics to the test cases. In DOORS, the project manager opens the verification test module to view the synchronized test cases from vManager with an out link to the requirement. We can see the test cases have been linked to the Verification Requirements module. Under each verification item, we can see the heading, description as short text, and all synchronized attributes like priority and status.

After reviewing the vManager test cases as verification items in DOORS, the project manager makes changes to the short text and then the status for the first test case, adjusting the specs for the tests to be performed. They then change the short text for the second test case. In both test cases, we can see the object text consisting of links attached to V Plan. Here, we can see the link to the Verification Test module in the Verification Requirements module in vManager. The verification engineer refreshes the page to view the changes made to the test cases in DOORS.

At this point, the verification engineer, as per protocol, goes to the regression center, runs the regression. Once the regression is complete and the coverage output is available in the regression center, it is synced and integrated into the planning center. In this demo, we are using pre-calculated coverage output for the metric port attached. Therefore, we will directly fetch the coverage outputs like grade average, past runs, and fail runs. To do so, the verification engineer clicks on Grade Analysis. This button enables OpsHub to show the pre-calculated coverage output.

Once the values are available at the planning center, the verification engineer fetches them from V Plan or its database to the attribute level. By clicking on Sync, we can see the values have been updated. OpsHub, via a CUDA script, allows the roll-up of results from the test case to a section or subsection level. Therefore, the results are identical at the Gluco Monitoring Machine level, which is the parent requirement. We can see the average result of both the test cases. This result is rolled up to the Health Monitoring Device section.

Navigating to DOORS to see similar outputs, the project manager enters the Verification Test module and clicks on the Low Blood Sugar Verification Test. Here, we can see four failed runs, two past runs, and the average grade is 33%. Based on this, the project manager changes the status of the test case to “Failed”. For the second test case, since the average grade is 100%, with zero failed runs and six past runs, the project manager changes the status to “Completed”.

Let’s take a look at the rolled-up results at the Requirements object level. Under High Blood Sugar Range Verification, we can see a 100% grade average, six past runs, and zero failed runs. Under Low Blood Sugar Range Verification, we can see a 33% grade average, four failed runs, and two past runs. The average rolled-up result at the parent requirement level is 66.66%, with four failed runs and eight pass runs. The same result is rolled up at the Health Monitoring Device 2.0 level. The project manager has now changed the status of the requirement to “Closed”.

Navigating to vManager, while the requirement update is syncing, the verification engineer refreshes the page to view the updates made to the test cases in DOORS. The test for High Blood Sugar Notification Verification is marked as “Passed”, whereas the test for Low Blood Sugar Notification is marked as “Failed”. The verification engineer refreshes the vManager page one last time to view the updated status of the requirement. The status change made to the requirement in DOORS has successfully synchronized and is reflected as “Resolved”.

That completes the demo. Thank you for watching.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Digital.ai Agility Integration with Jira and OpenText ALM

In today’s fast-paced business environment, legacy systems are outdated as they provide limited capabilities for business success. For timely delivery of quality products to market, organizations need an enterprise planning solution that drives consistency and efficiency by scaling agile practices across all levels, from teams to the entire product portfolio. By integrating Digital.ai Agility with Jira and OpexText ALM (Formerly known as Micro Focus ALM, HP ALM) using OpsHub Integration Manager (OIM), the product team, development team, and QA team can achieve complete information, visibility, traceability, and coordination in a heterogeneous environment, with access to all historical and current data in their preferred system in real-time. Take a look!

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

When it comes to effective portfolio management of multiple projects between cross-functional teams, having enterprise-grade integration support is crucial to deliver high-quality products faster. Product managers need quick visibility into development progress. Similarly, developers need clarity on customer expectations and business requirements. Today, we will show how integrating Digital.ai Agility, Jira, and OpenText ALM (Formerly known as Micro Focus ALM, HP ALM) used by the product owner, developer, and QA team, creates a seamless communication chain across the product lifecycle.

Digital.ai Agility is a powerful agile planning solution that drives consistency and efficiency by scaling agile practices across all levels, from teams to the entire product portfolio, while Jira is an issue or work execution tool that enables bug tracking and agile development. Let’s see how OpsHub Integration Manager (OIM) enables the integration between Digital.ai Agility, Jira, and OpenText ALM and offers product managers, developers, and QA teams cross-functional data in their preferred system.

The product team in Agility adds a new portfolio item, gives it a title, description, and priority, and saves it. In Jira, the development team views the recently synced portfolio item from Agility as a feature. All details attached to the portfolio item, including the title, description, remote ID, remote link, and priority added in Agility, are also reflected here under the feature. The development team in Jira now starts planning for the feature, adds a comment as a clarification, and attaches a file, which will get bidirectionally synced back to Agility.

This will help the product and development teams collaborate effectively for feature clarification. Back in Agility, the product team clicks on the portfolio item to view the attachment, remote ID, remote link, and comment from Jira, and as a reply to the development team, adds a comment. In Jira, the development team refreshes the page to view the recently added comment, which has synced back from Agility. The development team now goes ahead and changes the status of the feature to In Progress and breaks the feature into user stories. Under the user story, the development team adds a title, description, and a parent-child relationship.

The user story created in Jira will also get synchronized to OpenText ALM as a requirement, giving the QA team visibility for testing. We can see that the user story has been created back in Agility. The product team refreshes the page to view the user story, which has automatically synced from Jira, along with the status of the portfolio item, which is also reflecting In Progress. Under the user story, the product team views the recently synced title, description, remote ID, and remote link. Navigating to OpenText ALM, the QA team views the user story and begins creating test cases.

These test cases will synchronize to Agility and Jira with their relation to stories. This way, the product and development teams will get complete clarity on the testing strategy for a given user story. Under the test case, the QA team adds a name and description and changes the status to New. The QA team now links the test case to the same user story. Back in Jira, the development team views the test case, which has synced back from OpenText ALM. The same test case created in icr OpenText ALM is also reflected in Agility.

We can see all details associated with the test case also synced back. The product team in Agility now adds a comment as a suggestion for the testing strategy and saves it. This will get synchronized to Jira and OpenText ALM. In OpenText ALM, the QA team views the comment from Agility and refines the test accordingly. Once done, the QA team adds a comment as a reply, notifying the product team of the same. Back in Agility, the product team refreshes the page to view the comment added in OpenText ALM.

We saw how the product team in Agility and the QA team in OpenText ALM collaborated effectively to work around the issue while providing the development team in Jira with complete visibility into the latest activities at all times. Here in Jira, we can see both the comments from Agility and OpenText ALM synced successfully. The development team in Jira now goes ahead and changes the status of the user story to Done, marking the completion of the same. In OpenText ALM, the QA team views the updated status of the requirement to “Complete” and changes the status of the test case from New to Passed.

In Jira, the development team views the updated status of the test case, which is reflecting Done, and then changes the status of the feature from “In Progress” to “Done”. Finally, navigating to Agility, the product team refreshes the page to view the recently synchronized status of the feature, user story, and test case. Here, we can see the status of the user story showing “Resolved”, the status of the test case indicating “Passed”, and the status of the feature reflecting “Closed”.

This completes the demo. Thank you for watching.

OpsHub Integration Manager (OIM) integrates Digital.ai Agility with 60 best-of-breed industry systems.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

IBM DOORS – Modern Requirements4DevOps Migration

Adopting an incremental, agile, and high-fidelity content migration approach can significantly help enterprises with enhanced cross-functional collaboration and improve their requirements process. For example, migrating data from IBM DOORS to Modern Requirements4DevOps using OpsHub Migration Manager (OMM) helps enterprises create a unified ecosystem with a central source of truth. Watch the following migration demo video to learn how OMM facilitates high fidelity data migration along with history and no data loss from IBM DOORS to Modern Requirements4DevOps with Azure DevOps built on top of it. This, in turn, helps enterprises to modernize their requirements at their comfort and pace without compromising data integrity and compliance.

Experience scalable, non-disruptive migration with OMM

Schedule a free 30-minute live demo with our migration experts

Video Transcript

In this demo, requirements will be migrated from IBM DOORS to Modern Requirements. The Modern Requirements UI, built on top of Azure DevOps, will be used for this process. All requirements from IBM DOORS will be migrated to the Project Demo project. Currently, there are no backlogs, and the project is empty. Let’s quickly review the data in DOORS that will be migrated.

The data is stored in the Migration Demo module, which contains several requirements. These requirements are organized hierarchically with parent, child, and child of child relationships. Some of the data includes attachments, such as images and files.

The properties of the requirements are visible once opened. For example, the status is assigned to Seema, with the status set to “Resolved” and the priority set to 1. Additionally, all historical events related to the requirements, including status changes and user actions, will be migrated. For instance, the status changed from “None” to “Active,” and then from “Active” to “Resolved” on March 29th. Once migrated to Modern Requirements, this history will be preserved.

Another requirement contains a table and formatted data, which, along with the history and attributes, will be migrated as well. The migration has been pre-configured, and it will take just a minute to transfer all the requirements to Modern Requirements.

Refreshing the browser, most of the requirements are already visible, and the hierarchy remains intact, just as seen in DOORS. During migration, users still using DOORS will experience no disruption.

Let’s view one of the migrated requirements. The title and description are identical to the original in DOORS. The full status transition, including users and dates, is also replicated in Modern Requirements.

For end users, the transition from DOORS to Modern Requirements will be seamless. They will see the same data but gain access to enhanced features and functionality.

The hierarchy of parent, child, and child of child requirements is also retained. Refreshing again, all requirements are present. Opening another requirement, the attachments, or OLE objects, are carried over. In DOORS, two attachments were added: a Word document and a text file. These attachments remain unchanged when migrated.

The data is preserved with all formatting intact, ensuring there is no data loss. The tool has only been upgraded for better functionality. For users who need the DOORS requirement ID, it’s available in a field, and any comments or discussions from DOORS are retained, with the same user and timestamp.

Let’s now simulate a scenario where changes are made in DOORS while migration is ongoing. The DOORS team updates a requirement called “Creating a SAS Application,” adding “Cloud Computing” to the description and marking it as “Resolved.” These changes are saved and closed in DOORS.

While migration continues, a user in Modern Requirements updates the description, adding a short text. This change is saved and closed as well.

This demonstrates that migration isn’t a one-time event. While the migration happens, ongoing changes must also be migrated to Modern Requirements.

In Modern Requirements, the status is marked as “Resolved,” and the description is updated with “Cloud Computing.”

Importantly, during this demo, OpsHub is nowhere in the picture. This is the experience users will have—both in Modern Requirements and DOORS. Checking DOORS, the changes made in Modern Requirements, such as the addition of “Elastic Caching” and a search field, are reflected in DOORS as well.

This concludes the demo.

Experience scalable, non-disruptive migration with OMM

Schedule a free 30-minute live demo with our migration experts

TeamForge - ServiceNow Integration

Development and customer support teams often face challenges in prioritizing the most essential and critical fixes and enhancements from the customer standpoint. By improving cross-functional visibility between ALM tools such as TeamForge and ITSM tools like ServiceNow, teams can work on the most important features and defects, releasing high-quality products faster. Integrating TeamForge with ServiceNow using OpsHub Integration Manager (OIM), development and support teams can achieve near to real-time visibility into status, activities and issues within and across projects. This helps solve customer issues faster, increasing team productivity and efficiency. In the first phase of this video, we will demonstrate how to create and bidirectionally synchronize an enhancement request created in ServiceNow to TeamForge. In the second phase, we will show how a problem logged by the customer related to the same enhancement request is seamlessly solved by the support team in ServiceNow and the Development team in TeamForge. Take a look!

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts

Video Transcript

TeamForge is an ALM platform for traditional and hybrid software development, delivery, and collaboration. It reduces IT support costs and drives standardization and IP reuse. By integrating TeamForge with other tools in the software lifecycle, teams can build an integrated pipeline from planning through deployment to deliver high-quality products to customers at a faster pace.

OpsHub Integration Manager supports the integration of TeamForge with 60+ ALM, DevOps, ITSM, and CRM systems. In this video, we will showcase how OpsHub facilitates the integration of TeamForge with ServiceNow.

The support team in ServiceNow creates an enhancement request, adds descriptions, priority, and status, and saves it. The enhancement request synchronizes to TeamForge as a feature, providing the development team with visibility into the feature they need to work on. The enhancement request created in ServiceNow is successfully reflected in TeamForge along with all its details, including the remote ID and remote link.

The development team in TeamForge now starts planning the feature, adding a clarification question in the form of a comment for the support team in ServiceNow. In ServiceNow, the support team reviews the comment added by the development team, which has synchronized successfully, and adds a reply and an attachment for clarification. Both the comment and the attachment added in ServiceNow are bidirectionally synced to TeamForge. This bidirectional synchronization enables the support and development teams to collaborate effectively on feature clarification.

In TeamForge, the development team refreshes the page to view the attachment and comment added in ServiceNow and then changes the status to Pending and saves it. The development team in TeamForge now starts breaking the feature into two user stories. The development team adds the first user story, gives it a title, description, and dependencies, and creates a parent-child relationship. The first user story is successfully created, and the development team similarly creates the second user story.

As the user stories are created, the QA team in TeamForge gains visibility into them. In ServiceNow, the status changes made in TeamForge are successfully reflected along with the two user stories. Back in TeamForge, the development team changes the status of both user stories to indicate to the QA team that they are ready for testing. The status changes made in TeamForge are successfully reflected in ServiceNow.

In TeamForge, the QA team starts adding test cases. For the first test case, the QA team adds a title, description, and dependencies to create a parent-child relationship and similarly adds the second test case. Both test cases are successfully created. The QA team changes the status of the test cases to “Passed” after fulfilling the expected results.

The development team then navigates to the feature and changes the status to “Closed”, indicating completion of the feature. This change automatically synchronizes back to ServiceNow. Finally, in ServiceNow, the development team refreshes the page to view the synchronized status of the user stories as “Resolved” and the status of the enhancement request as “Closed”. This completes phase 1 of the demo, where we showed the creation and bidirectional synchronization of an enhancement request from ServiceNow to TeamForge.

In phase 2 of the demo, we will show how a problem logged by the customer related to the same enhancement request is seamlessly resolved by the support team in ServiceNow and the development team in TeamForge. The customer in ServiceNow creates an incident ticket. The support team in ServiceNow clicks on the ticket, verifies all details, identifies the issue, adds a comment asking the customer for additional details, and saves it.

The support team in ServiceNow creates a problem ticket from the incident ticket, adds descriptions, sets the priority to “High”, updates the status, and links the problem ticket with the enhancement request by providing the ticket number in TeamForge. The problem created in ServiceNow synchronizes successfully as a defect in TeamForge along with all its details. This defect in TeamForge can be traced back to its associated feature under Associations.

The development team in TeamForge analyzes the issue and adds a comment as a reply, requesting additional details. In ServiceNow, the support team reviews the comment added by the development team in TeamForge and replies with a comment. The comment added in ServiceNow is bidirectionally synced back to TeamForge. In ServiceNow, the support team navigates to the incident ticket to find the customer’s comment and additional details as requested, downloads the attachment, and adds a reply to the customer.

The support team then changes the status of the incident to “Active “and saves it. The support team navigates to the problem ticket and attaches the additional details received from the customer along with a comment notifying the development team of the same. The details and comment added in ServiceNow automatically synchronize back to TeamForge.

The development team in TeamForge refreshes the page to view the synchronized attachment and comment and adds a reply to the support team in ServiceNow. The development team starts working on the defect, changes the status to In Progress, sets a completion date, and saves it. The status change and due date set in TeamForge successfully reflect in ServiceNow, providing the support team with clarity and visibility into the release date and progress of the problem. The comment added in TeamForge also reflects in ServiceNow.

In TeamForge, once the fixes are completed, the development team adds a comment and changes the status of the defect to “Closed”, indicating its resolution. Back in ServiceNow, the support team refreshes the page to view the updated status of the problem ticket as “Closed” along with the comment. Finally, the support team navigates to the incident ticket to notify the customer of the resolution and changes the status to “Closed”, indicating closure of the incident ticket.

This completes the demo. Thank you for watching.

Experience seamless integration & eliminate data silos with OIM

Schedule a 30-minute live demo with our integration experts