Integration Patterns
The Planview team has been fortunate to work with software innovators across the spectrum of vertical industries. And while every organization is unique, our broad experience has allowed us to uncover and optimize for certain common software lifecycle integration patterns.
Key benefits of toolchain integration:
- Eliminates overhead and duplicate data entry
- Accelerates delivery speed
- Enhances cross-team collaboration
- Improves time-to-value and mean time-to-resolution
- Enables end-to-end visibility and measurement
- Creates traceability for compliance and continuous improvement
In addition to the six common benefits of toolchain integration listed above, each integration pattern provides specific benefits to a particular set of practitioners.
Where to start?
We normally recommend that organizations identify the scenarios that are causing the most immediate pain and enable the associated integration patterns. Over time, organizations adopt and deploy more and more of these foundational integration patterns, creating chained patterns that achieve end-to-end flow.
The diagram below illustrates the integration patterns that facilitate flow between the Ideation, Creation, Release and Operation phases of software delivery. We’ll be breaking these down these patterns one-by-one.
Foundational Integration Patterns
Foundational integration patterns flow and synchronize work between two distinct roles working in two (or more) different tools. For example, flowing defects logged by a test engineer in a Testing tool to the responsible developer working in an Agile planning tool. In a software delivery organization that uses two Agile planning tools, you can imagine that some defects may flow to Jira, while others will flow to VersionOne.
There are many foundational patterns, so the easiest way to explore them is by considering the triggering activity for the integration. When does the triggering activity occur?
- Is it in the Ideate phase, when you’re planning, gathering requirements and designing feature work?
- Is it in the Create phase, where you’re developing, building and testing features, or resolving defects?
- Is it during the Release phase, when you’re releasing code changes to production?
- Or is it in the Operate phase, where you are supporting existing customers and production environments?
The foundational integration patterns include:
Ideate
Associating Planning Items to Implementation Artifacts
Pattern Name: Plan implementation
Tools Typically Integrated: PPM or Roadmapping with Agile Planning
The Project Management Office (PMO) often uses a PPM tool, such as Planview or CA PPM, to help manage organizational initiatives and investments in the application portfolio. In recent years, product-centric organizations have adopted roadmapping tools for their strategic planning.
At the same time, the product and development teams tasked with executing against these high-level business themes manage their work in Agile planning tools.
This integration pattern mirrors the high-level planning items managed in the PPM or roadmapping tool directly into the Agile planning tool, from which they can be broken down into epics, user stories, tasks and sub-tasks.
Benefits
-
Both parties benefit from a seamless flow of work from the ideation teams to the implementation teams.
-
In addition, as work progresses, updates flow back upstream, providing the portfolio managers with visibility on execution and completion against the plan.
Artifacts Typically Synchronized
|
Planning Items |
Implementation Artifacts |
|
|
Example of this Pattern
Associating Planning Items to Requirements
Pattern Name: Plan Requirements
Tools Typically Integrated: PPM or Roadmapping with Requirements Management
Some initiatives or features defined in PPM tools, like Planview or CA PPM, or product roadmapping tools, may actually represent requirements for the product and development teams. Organizations that develop very complex products in heavily regulated industries use Requirements Management tools like Jama, IBM DOORS NG and Polarion ALM for their product specifications.
This integration pattern mirrors the high-level planning items managed in the PPM or roadmapping tool directly into the Requirements Management tool, from which they can be broken down into requirements, user stories or epics.
Benefits
-
Both parties benefit from a seamless flow of work from the planning teams to product management teams.
-
In addition, as work progresses, updates flow back upstream providing the portfolio managers with visibility on execution and completion against the plan.
Artifacts Typically Synchronized
|
Planning Items |
Implementation Artifacts |
|
|
Example of this Pattern
Providing Developers with Early Visibility into Requirements
Pattern Name: Dev Requirements Visibility
Tools Typically Integrated: Requirements Management with Agile Planning
Organizations that develop very complex products in heavily regulated industries use Requirements Management tools like Jama, IBM DOORS NG and Polarion ALM for their product requirements.
The development teams that need to implement those requirements would prefer to have them flow into their Agile planning tools automatically as epics or features, in tools like Jira, CA Agile Central or Targetprocess. Then, these artifacts can be broken down into user stories, maintaining the relationship to the parent epic and its associated requirement for traceability.
Benefits
-
Both parties benefit from a seamless flow of work from the planning teams to product management teams.
-
In addition, as work progresses, updates flow back upstream providing the portfolio managers with visibility on execution and completion against the plan
Artifacts Typically Synchronized
|
Requirements |
Implementation Artifacts |
|
|
Example of this Pattern
Providing Testers with Early Visibility into Requirements
Pattern Name: Test Requirements Visibility
Tools Typically Integrated: Requirements Management with Testing Tools
Including QA and Test teams in the earliest phases of the software delivery lifecycle ensures they have ample time to work on the test cases that will cover the requirements.
This integration patterns mirrors and synchronizes requirements or user stories authored in Requirements Management tools to the testing tools, like Micro Focus ALM, where test plans, test cases and test scripts are created. If tests are systematically linked to the originating requirement, you can easily identify which tests might need to be updated when a requirement is changed, or when functionality is removed from the product. It also provides the Product teams with visibility into test coverage as testing progresses, if supported.
Benefits
-
Improve product quality by providing QA teams early access to requirements with ample time to plan good test coverage
-
Changes to requirements are seamlessly communicated to the QA teams
-
Product managers and business analysts have visibility into test coverage (completion) for each requirement
-
Traceability is maintained between requirements and their tests, ensuring proper test coverage when a requirement changes, and preventing over-testing when a specific functionality is removed
Artifacts Typically Synchronized
|
Requirements |
Testing Artifacts |
|
|
Example of this Pattern
Associating Requirements to Detailed Design
Pattern Name: Requirements Detailed Design
Tools Typically Integrated: Requirements Management with Requirements Management or Enterprise Architecture
The process of defining and designing a product and its features often spans multiple tools. For example, requirements may be authored in a Requirements Management tool and then elaborated on in a modeling tool, where the customer experience and business processes are fully detailed and supplemented with wireframes, mockups, diagrams and more.
This integration pattern mirrors and synchronizes requirements from a Requirements Management tool into additional tools used for detailed design, like Storyteller or Sparx EA.
Benefits
-
Product managers, business analysts and designers collaborate seamlessly to develop comprehensive and clear requirements
-
The relationship between requirements and their detailed designs are fully traceable
Artifacts Typically Synchronized
|
Requirements |
Detailed Design |
|
|
Example of this Pattern
Populating Requirements into PLM Tools
Pattern Name: Requirements Visibility in PLM
Tools Typically Integrated: Requirements Management with PLM
PLM tools are central to organizations developing products that combine both hardware and software components. The complexity of these products often requires both PLM and ALM tool stacks, which are not commonly integrated. Both product management and the development teams can greatly benefit from an integration that creates powerful automated workflows that bridge the two stacks.
This pattern represents one such workflow, whereby requirements created in a best-in-class Requirements Management tool (e.g., Jama, IBM DOORS NG, Sparx EA) automatically flow to a PLM tool (e.g., Aras or Windchill) where they can be consumed and referenced. Thus, the entire organization can use one purpose-built tool to manage both the hardware and software requirements, and any changes to requirements' basic and custom data fields will be reflected in PLM.
Benefits
- Reduce errors in product data and eliminate rework
- Streamline the design-to-manufacturing workflow
- Create efficient traceability back to the originating requirement
Artifacts Typically Synchronized
|
Implementation Artifacts |
PLM Artifacts |
|
|
Create
Sharing Stories and Defects between Dev and Test
Pattern Name: Dev and Test Collaboration
Tools Typically Integrated: Agile Planning with Testing Tools
This is the most common integration pattern found in software delivery organizations, which integrates testing tools with Agile planning tools. It focuses on improving collaboration between development and test teams and, as a result, improving product quality.
This integration pattern:
-
Flows stories from Agile planning tools to testing tools. This helps testers plan for the right test coverage and also creates traceability between a story or task to the test cases designed for it.
-
Flows defects from testing tools to Agile planning tools. Defects logged in testing tools are mirrored and synchronized into the developers’ Agile planning tools, where the developer can work on resolving it. As the developer updates the status of the issue, the status flows back to the originating defect in the testing tool, informing the testing teams when they can proceed to retest it.
Benefits
-
Optimize testing efforts by providing early visibility into stories and tasks.
-
Improve product quality and speed of defect resolution, by automating the flow of defects between test and dev.
Artifacts Typically Synchronized
|
Development Artifacts |
Testing Artifacts |
|
|
Examples of this Pattern
Aligning Developers across Agile Planning Tools
Pattern Name: Dev Alignment
Tools Typically Integrated: Agile Planning with Agile Planning
It is not uncommon that within a single company or agency, multiple Agile planning tools, or multiple instances of a specific tool, are used. This might be due to team preference, legacy tooling, technology needs, or Agile methodology. Whatever the reason, teams still need to collaborate and managers need cross-tool visibility on development activity and performance.
This integration pattern synchronizes implementation artifacts between two or more Agile planning tools. The flow may be fully bi-directional, meaning all artifacts are replicated fully across all tools, or it may be more directed - replicating artifacts from multiple sources into a single tool.
Benefits
-
Allows Agile teams to collaborate across tool boundaries
-
Creates full traceability of related work across tools
-
Allows flexibility for each development team to choose the Agile planning tool that best meets their needs
Artifacts Typically Synchronized
|
Development Artifacts |
|
Example of This Pattern
Multiple Jira Instances
Jira and VersionOne
Aligning Testing Teams across Testing Tools
Pattern Name: Test Alignment
Tools Typically Integrated: Testing Tool with Testing Tool
With the introduction of automated testing and the advances in testing tools, software delivery organizations often use multiple testing tools for their QA purposes. One tool may be used for test management, test execution, defect tracking, and reporting, while another is used for automated testing.
This integration pattern flows information between the testing tools to create a consolidated view of defects for collaboration, reporting and analysis.
Benefits
-
Improves product quality by seamlessly supporting the use of multiple, specialized testing tools
-
Enables cross-tool reporting on defects
Artifacts Typically Synchronized
|
Testing Artifacts |
|
Example of this Pattern
Linking Code Changes to the Originating Feature or Defect
Pattern Name: Code Traceability
Tools Typically Integrated: Version Control System with Requirements Management or Agile Planning
When dealing with millions of lines of code, it’s very important to know why the code was written in the first place. That means linking the code changes to the originating feature or defect. However, doing so manually is both tedious and error prone.
This integration pattern automates code traceability by automatically linking software requirements and defects to the lines of source code that implement them.
Two flavors exist for this pattern:
- Upon code commit, update an existing artifact (requirement, user story, defect or task) with the link to the changeset.
- Upon code commit, create a new artifact for the changeset and link it to an existing artifact (requirement, user story, defect or task).
Benefits
-
Ensure every line of code is traceable back to its originating feature or defect. This is exceptionally important for any safety critical product and products designed for decades of use and maintenance (e.g., airplanes).
Artifacts Typically Synchronized
|
Code Changes |
Implementation Artifacts |
|
|
Example of this Pattern
Reporting Known Defects to the Help Desk
Pattern Name: Known Defect Reporting
Tools Typically Integrated: Agile Planning with ITSM (Service Desk)
When a new release of an application is put into production, it is frequently the case that the development team was not able to address all known defects. However, in order to provide excellent service to its customers and to avoid triaging an incident only to discover later that it is a known problem, the help desk must be made aware of these defects.
This integration pattern mirrors defects from developers’ defect tracking systems (often Agile planning tools) directly to the help desk software. Any updates are bi-directionally synchronized. For example, if additional information about the problem is reported to the help desk, this information can augment the defect report. Similarly, if progress is made against fixing the defect, that information is immediately available to the help desk.
Benefits
-
Customer issues caused by known defects are handled faster.
Artifacts Typically Synchronized
|
Development Artifacts |
Testing Artifacts |
|
|
Release
Providing Release Visibility and Traceability to Product and Dev
Pattern Name: Release Visibility
Tools Typically Integrated: Release Orchestration and Automation with Agile Planning
Release information appears on a lot of artifact types. In some tools, the release itself is a first class citizen; in others, the release is a field on a work item.
This release pattern makes it easier to designate one tool as the source or 'master' of the release artifact and use synchronization to populate the release artifact to other tools to be consumed there. It mirrors a release created in one tool, for example a Release Orchestration and Automation tool, and synchronizes it (with name, description, start & end dates, status, and other fields) into other tools (e.g., Agile planning tools). As the release progresses, its status is visible in all tools.
Benefits
-
Eliminate duplicate data entry and human error. Release information is populated automatically from the source to other tools.
-
Create visibility into the release status for practitioners who don't normally use Release Orchestration tools, like product owners, project managers and developers.
-
Create traceability between artifacts and releases by flowing the information through Planview Hub's models.
Artifacts Typically Synchronized
|
Release Artifacts |
Ideation Artifacts |
Implementation Artifacts |
|
|
|
Example of this Pattern
Creating Defects from Release Pipeline Failures
Pattern Name: Release Pipeline Defects
Tools Typically Integrated: Continuous Delivery Tools with Agile Planning
Before releasing software to production, many DevOps tools may be triggered (manually or automatically) triggered to ensure the quality of the code and to prevent destabilizing of a production environment. A good example of that is scanning for security vulnerabilities with a tool like WhiteHat Sentinel or a crash from a tool like New Relic.
This integration pattern takes errors generated by those tools during the release process and automatically creates them as defects in the testing tools or Agile planning tools, so they can be immediately addressed.
Benefits
-
Resolve failures faster to minimize impact
-
Improve compliance by providing traceability between defects (e.g., security vulnerabilities) and fixes.
Artifacts Typically Synchronized
|
Release Artifacts |
Implementation Artifacts |
|
|
Example of this Pattern
Operate
Escalating Help Desk Problems to Developers
Pattern Name: Software Problem Escalation
Tools Typically Integrated: ITSM (Service Desk) with Agile Planning
So many IT support professionals are frustrated by having to duplicate information about tickets from ServiceNow into other tools. Teams are wasting valuable time trying to keep records up-to-date in multiple systems and sending emails and chat messages to follow up on details and statuses. The fact that teams use different systems of record and different workflows makes collaboration and communication between IT support staff and developers very challenging.
This integration pattern eliminates those issues by creating a completely visible and traceable defect reporting and resolution process. It automates the flow of information across tools, synchronizing work items created in ITSM tools directly into the Agile planning and issue tracking tools used by developers, like Jira, VSTS or many others.
Note: This pattern also allows for nuance; if the support engineer can discern whether the issue is truly a bug or a customer change request, bugs can flow to the developers as defects and change requests can flow as user stories.
Benefits
-
Streamline the issue escalation processes, while providing transparency to the support engineer as work on the issue progresses.
-
Generate insight into the contributing factors to your true MTTR and identify the bottlenecks slowing down resolution times.
Artifacts Typically Synchronized
|
Service Desk Artifacts |
Implementation Artifacts |
|
|
Example of this Pattern
Assigning Hardware Problems to Engineers in PLM
Pattern Name: Hardware Problem Escalation
Tools Typically Integrated: ITSM (Service Desk) with PLM
When products involve both hardware and software components, escalated help desk issues have to be routed to the appropriate team for resolution. Doing so manually through either duplicate data entry, emails, chats or meetings is inefficient and impacts the speed and quality of the resolution, usually at the customer's expense.
This integration pattern dispatches the issue recorded in a service desk solution (e.g., ServiceNow, BMC Remedy) to the appropriate engineering team. It flows hardware problems to the relevant teams working in a PLM tool (e.g., Aras or Windchill) for investigation and resolution, while software issues can flow as defects to software developers working in Agile Planning Tools. It facilitates the collaboration between the support team and the engineers and creates visibility on how the resolution is progressing.
Benefits
-
Eliminate manual duplicate data entry between two systems of record, to improve efficiency and data integrity.
-
Streamline the ticket resolution processes, while providing transparency to the support engineer as work on the issue progresses.
-
Generate insight into the contributing factors to your true MTTR and identify the bottlenecks slowing down resolution times.
Artifacts Typically Synchronized
|
Service Desk Artifacts |
PLM Artifacts |
|
|
Sharing Customer Feature Requests with Product
Pattern Name: Feature Request Visibility
Tools Typically Integrated: ITSM (Service Desk) or CRM with Requirements Management or Agile Planning
Prospects and existing customers frequently raise requests to your customer-facing teams, including things like product enhancements. This pattern automates the flow of those requests from the business or support teams, working in a CRM like SalesForce or an ITSM tool like ServiceNow, to the product teams. It connects a customer request with a product request, feature or requirement in an Agile Planning tool. It's also possible to flow the request to the tool Product Managers use like a Requirements Management tool. As work on the request progresses, the synchronization ensures business teams have visibility on its progress and can communicate accordingly with their customers.
Benefits
-
Product teams gain seamless visibility into customer needs without any manual work or correspondence outside CRM.
-
Sales and account teams can manage all the information about the account and opportunity in a single location,
Artifacts Typically Synchronized
|
Operation Artifacts |
Design Artifacts |
|
|
These patterns can be implemented within a single enterprise or agency, or applied across organizational boundaries, for example when collaborating with subcontractors.
Chained Integration Patterns to Achieve End-to-End Flow
After starting with Foundational Patterns, most organizations move on to connecting multiple patterns together to achieve a seamless, automated flow of work and traceability across tools. Once connected in this way, it is possible to generate useful reports and meaningful metrics on the flow of value through the software delivery value stream, known as Flow Metrics.
Popular chained patterns include:
Requirements Implementation Traceability
Incident Resolution Traceability and Visibility
Customer Request Traceability and Visibility