6 Requirement to Deploy (R2D) Value Stream
This chapter provides an overview of the Requirement to Deploy (R2D) Value Stream – one of four IT Value Streams that comprise the IT Value Chain. It describes the business context, objectives, and details behind the R2D Value Stream.
6.1 Objectives
The R2D Value Stream is designed to ensure predictable, cost-effective, high quality results to the business while also promoting high levels of re-use, flexibility, speed, and collaboration across IT to support traditional and new methods for service creation and sourcing.
Make service delivery predictable, even across geographically dispersed teams, multiple suppliers, and multiple development methodologies. Applications and services today are sourced or developed in cooperation with many different parties. All parties are working with their own processes and tooling. IT must be able to provide a good overview of the planned activities, should speak a common language with all parties involved, and should provide a methodology for how to achieve the highest quality results. Cloud sourcing, agile development, and other innovations have created the need for IT to be able to manage development and delivery of services in a hybrid or multi-sourced environment.
Ensure that each Service Release is high quality, fit-for-purpose, and meets customer expectations. IT still experiences too many incidents immediately after release of an application or service into production. IT must establish control over the quality of a service regardless of the number of vendors involved in development and/or delivery.
Understand the evolving relationship between planning and building. Historically, estimation has been framed as a trade-off, balancing a prior “planning” phase versus a later “building” phase. However, it is increasingly understood that planning in complex domains requires information only available through iterative attempts to fulfill requirements. In a sense, both planning and building must take place simultaneously in many cases.
Standardize service development and delivery to the point where re-use of service components is the norm. IT operations and development must ensure increased quality and speed of service delivery while also lowering costs. In support of these efficiency and quality goals, IT must have a framework in which to drive the re-use of existing service components at multiple stages of the development lifecycle across multiple applications and services. IT must work successfully with multiple internal and external contributors and be able to integrate the data, process, and tools required to work with geographically dispersed teams, outsourcers, and traditional and cloud-based suppliers. Furthermore, IT must maintain control of the governance of the R2D Value Stream and be able to track and measure internal and vendor performance, costs, quality, and on-time delivery. The ability to re-use requirements, source code, documentation, test scripts, service monitors, and other data objects of the service development lifecycle is a key contributor to managing cost, increasing quality and predictability, and accelerating release cycles.
Build a culture of collaboration between IT operations and IT development to support Service Release success. IT operations and development must improve collaboration between departments. Development organizations build and test services in a silo and “surprise” IT operations by “throwing release packages over the fence” for immediate delivery. IT operations may not be able to accommodate new technologies and environments fast enough to meet the requirements of developers. Inefficient manual processes are typical, and in high maturity shops are increasingly replaced by fully automated continuous delivery pipelines.
Put rigorous information management controls in place to lessen the impact of the IT reality – high staff turnover. High turnover in IT means knowledge is lost and schedules are impacted. Particularly in low-cost labor markets where employers are suffering high employee turnover rates. The R2D Value Stream helps capture the knowledge that would otherwise be lost and cause schedules to be delayed.
Drive predictable outcomes without driving out innovation. Innovation and process efficiency are two pillars of competitive advantage that IT departments bring to the business, yet these two pillars often have trouble co-existing. The emphasis on on-time project delivery tends to stifle innovation, creating a conflict between these two priorities. IT must continuously improve its ability to execute in such a way that on-time innovation is the norm. The R2D Value Stream identifies the core automation enablers and the key data exchanges required to accomplish this goal. For example, focusing efforts on automation of test, release, and deployment provides more time and resource for innovation in service design and development.
6.2 Business Value Proposition
The R2D Value Stream describes a prescriptive framework of required functional components and data objects so IT organizations can better control the quality, utility, schedule, and cost of services regardless of the delivery model.
The key value propositions for adopting the R2D Value Stream are:
- Maximize the pipeline of projects and smaller grained demand requests for faster time-to-market in service realization.
- Predictable outcomes that ensure that the application or service delivered actually performs as requested, leading to higher rates of user acceptance and better business alignment.
- Establish control points to manage the quality, utility, security, and cost of services, independent of development method or delivery source.
- Increased management information for traceability and benchmarking of internal and external service developers and suppliers.
- Ensure that all services are designed in accordance with standards and policies (from sources including Corporate Compliance, Enterprise Architecture, Risk Management, IT Financial Management, and so on).
- Improved inputs to IT Financial Management on service cost.
- Relate applications and services with business value by creating and maintaining the service blueprint.
- Accelerate the sourcing and delivery of applications and services through best practices such as:
— Re-use – manage, maintain, and leverage re-usable IT components and services.
— Automation – identify the core functional components and data required to streamline the R2D Value Stream.
— Collaboration – use data to institutionalize collaboration of teams involved in the development lifecycle to expedite releases, and reduce incidents and rework that might otherwise result. This lays the foundation for new paradigms such as DevOps.
6.3 Key Performance Indicators
The R2D Value Stream critical success factors and Key Performance Indicators (KPIs) are as follows:
Critical Success Factors |
Key Performance Indicators (KPIs) |
Improve Quality |
Number of escaped defects % of actual versus planned executed tests % of critical defects found early in unit testing versus UAT |
Improve Project and Feature Execution |
% of projects (project tasks, stories, other demand requests) on time % of healthy projects (projects without unresolved urgent issues) Deviation of planned to actual work hours Number of identified issues Number of opened risks Amount of backlog/work-in-process Arrival and departure rate for work |
Improve Stewardship of IT Investment |
% of actual versus planned project cost % of change in project cost % of budget at risk |
Increase Automation Adoption |
% of automated tests |
Achieve Development Process Excellence |
% of requirements tested, authorized, completed % of requirements traced to tests % of reviewed requirements % of successful builds % of changes resulting in Incidents Ratio of detected to closed defects at release |
Improve Early Life Success of Releases |
% of Incidents during warranty period % of successful/unsuccessful deployments for the project % of emergency changes Pass rates on UAT/validated requirements |
Operations and Development Collaboration |
Trend on early life support/UAT success metrics % rework |
Improve Financial Visibility |
Planned cost versus actual cost |
Maintain a Linkage between Business Services and IT Initiatives |
Aggregate (roll up) service development costs by business service |
High Quality Service Design Specifications at the Outset |
% reduction in the rework required for new or changed service solutions in subsequent lifecycle stages |
Integration Test Success |
Trend on the number of installation errors in all the packages in the integration environment Number of applications or services that require exceptions outside of the existing infrastructure portfolio |
Design-Review to Ensure Application Design Complies with all Policies, including Security |
Number of application designs that pass a security policy review |
Early Testing of Applications for Security Vulnerabilities |
% of severity 1 security defects fixed before application is released |
6.4 Value Stream Definition
The Requirement to Deploy (R2D) Value Stream contains primary and secondary functional components. Primary functional components are core to the value stream and are essential for managing the service at this stage of its lifecycle. Secondary functional components are not dedicated to R2D but provide relevant data objects to primary functional components. The following functional components in the R2D Value Stream support the definition, development, and governance of the data objects and Service Model entities above:
- Build
- Build Package
- Defect
- Project
- Release Composition
- Requirement
- Service Design
- Source Control
- Test
The R2D Value Stream is process-agnostic in that while methods and processes may change (i.e., ITIL, COBIT, agile, waterfall, etc.), the functional components and data objects that comprise the value stream remain constant. The R2D Value Stream provides the framework for creating and sourcing a new or modifying an existing application or service. The R2D Value Stream is triggered if it receives a demand signal from a consumer or from other components such as Problem Management. This may take the form of an approved Scope Agreement and Conceptual Service from the S2P Value Stream, or may be a smaller grained signal such as an individual development story, user story, defect, problem, usage data, or scenario for a specific application or service. The R2D Value Stream ends when the requested service or modification is packaged for immediate or future deployment through an R2F Value Stream Fulfillment Execution functional component.
Figure 46: Requirement to Deploy Level 2 Value Stream Diagram
6.4.1 Project Functional Component
Purpose
Coordinate the creation and provide ongoing execution oversight of IT Initiatives aimed at the creation of new or enhancements to existing services. Create IT Initiatives based on the specifications outlined in the Scope Agreement, including cost, time, scope, and quality. Aggregate, track, and report status, resources consumed against project plan, or project burn down, and communicate these to stakeholders via auxiliary functional components such as Resource Management, Supplier Management, and IT Financial Management. Govern, coordinate, influence, and direct initiative execution. Ensure financial goals and boundary conditions are adhered to. Maintain the connection between initiatives and associated applications and service(s) being developed. Maintain the linkage/traceability between Scope Agreements, IT Initiatives, and Service Releases. Produce various request artifacts associated with financial, human, and technology resources (that is, feedback to the S2P Value Stream when variances cross thresholds). Coordinate the acquisition of resources (hardware, software, and people) required to source/create a service in a particular project.
Key Data Objects
- IT Initiative (data object): Details the scope of the work to be performed and created from and associated with the Scope Agreement.
Key Attributes
The IT Initiative data object shall have the following key data attributes:
- Id: Unique identifier of the effort/initiative.
- Name: Full name of the effort/initiative.
- Status: Status of the effort/initiative.
- ServiceReleaseId: Identifier of one or more Service Releases.
- RFCId: Identifier of one or more RFCs.
- Budget: Budget for the IT Initiative.
- ActualSpend: Actual spend on the IT Initiative.
- StartDate: IT Initiative start date.
- EndDate: IT Initiative completion date.
- ScopeAgreementId: Unique identifier of the related Scope Agreement.
Key Data Object Relationships
The IT Initiative data object shall maintain the following relationships:
- Scope Agreement to IT Initiative (1:n): Maintain a linkage between the proposal which authorized one or more IT Initiatives.
- IT Initiative to Service Release (1:n): An IT Initiative will manage the creation of one or more Service Releases required to deliver the IT Initiative.
- IT Initiative to Request for Change (RFC) (1:n): An Initiative will be related to one or many RFC records in order to manage all changes resulting from a single work effort (initiative).
Functional Criteria
The Project functional component:
- Shall be the system of record (authoritative source) for all IT Initiatives.
- Shall manage the lifecycle of the IT Initiative.
- Shall manage the status of the IT Initiative.
- Shall coordinate resources, finances, tasks, and milestones for IT Initiatives, and provide ongoing execution oversight of IT Initiatives when creating new services or enhancements to existing services.
- Shall create IT Initiatives based on the specifications outlined in the Scope Agreement, including cost, time, scope, and quality.
- Shall aggregate, track, and report status, resources consumed against project plan, or project burn down, and communicate these to stakeholders via auxiliary functional components such as Resource Management, Supplier Management, and IT Financial Management.
- Shall govern, coordinate, influence, and direct IT Initiative execution.
- Shall ensure financial goals and boundary conditions are adhered to.
- Shall maintain traceability between IT Initiatives and associated applications and service(s) being developed.
- Shall maintain the linkage/traceability between Scope Agreements, IT Initiatives, and Service Releases.
- Shall produce various request artifacts associated with financial, human, and technology resources (that is, feedback to the S2P Value Stream when variances cross thresholds).
- Shall coordinate the acquisition of resources (hardware, software, and people) required to source/create a service in a particular project.
- Shall track spend for IT Initiatives attached to each Scope Agreement and pass it to the Service Design functional component.
- Can submit one or more RFCs required for the IT Initiative if a Change Control functional component exists.
- Can manage the Subscription data flow to the Request Rationalization functional component if a Request Rationalization functional component exists.
- Can send a request to the Request Rationalization functional component when resources are required for the IT Initiative if a Request Rationalization functional component exists.
- Shall be able to receive the Scope Agreement from the Proposal functional component if a Proposal functional component exists.
- Can provide IT Initiative information required for Service Design to the Service Design functional component if a Service Design functional component exists.
- May receive the subscribed service charges from the Chargeback/Showback functional component if a Chargeback/Showback functional component exists.
- May send charge acceptance to the Chargeback/Showback functional component if a Chargeback/Showback functional component exists.
- May receive the development scope and agreement from the Service Portfolio functional component if a Service Portfolio functional component exists.
Data Architecture Criteria
The Project functional component:
- Shall allow recursive relationships between IT Initiatives.
- Shall associate an IT Initiative to a service.
- Shall associate an IT Initiative to one or more RFCs if a Change Control functional component exists.
- May associate an IT Initiative with an IT Budget Item in the IT Financial Management supporting function.
- Shall associate a Scope Agreement to one or more IT Initiatives if a Proposal functional component exists.
Model
Figure 47: Project Functional Component Level 2 Model
6.4.2 Requirement Functional Component
Purpose
Manage Requirements through the lifecycle of a service. Service-level requirements are captured as Requirements. Collect, refine, scope, and track progress of Requirements even before and after an IT Initiative has concluded. Maintain traceability of each Requirement to the original source (demand, IT or business standard or policy, and/or requestor) and to appropriate Source and/or Test Cases throughout the service lifecycle. Derive product or program backlogs which will ultimately serve as queues for enhancing IT services.
Key Data Objects
- Requirement (data object): Record which details the needs or conditions to meet for a new or altered service.
Key Attributes
The Requirement data object shall have the following key data attributes:
- Id: Unique identifier of a given Requirement.
- Type: Identifies the category of a Requirement (i.e., epic, theme, feature, user story, non-functional, functional, etc.).
- Summary: Represents the short description/title/summary of a given Requirement.
- LogicalServiceId: Unique identifier of the related Logical Service.
- RequirementSource: A reference to the Requirement source such as policy, backlog item, etc.
- Owner: The person or team that is assigned to this Requirement.
- ServiceReleaseId: Unique identifier of the related Service Release.
Key Data Object Relationships
The Requirement data object shall maintain the following relationships:
- Logical Service to Requirement (1:n): One or more Requirements will be used to define the required behavior from the Logical Service.
- Service Release to Requirement (1:n): The Service Release describes a version of the service which fulfills one or more Requirements.
- Requirement to Test Case (1:n): A Requirement is traced to one or more Test Cases to ensure stated needs or conditions have been successfully delivered or met.
- Portfolio Backlog Item to Requirement (1:n): A Portfolio Backlog Item is mapped to one or more Requirements which will need to be delivered to successfully fulfill the demand.
- Policy to Requirement (n:m): Requirements may be sourced from policies or may reference policies in order to remain in compliance to previously agreed policies for an organization.
- Requirement to Source (n:m): Source will fulfill one or many Requirements, and for a given Requirement, there could be multiple Sources created/modified.
Functional Criteria
The Requirement functional component:
- Shall be the system of record (authoritative source) for all Requirements.
- Shall manage the lifecycle of the Requirement.
- Shall manage the state of a Requirement.
- Shall manage Requirements through the lifecycle of a service.
- Shall capture service-level Requirements.
- Shall collect, refine, scope, and track progress of Requirements even before and after an IT Initiative has concluded.
- Shall maintain traceability of each Requirement to the original source (demand, IT or business standard or policy, and/or requestor) and to appropriate source and/or Test Cases throughout the service lifecycle.
- Shall derive product or program backlogs which will ultimately serve as queues for enhancing IT services.
- Can manage the data flow to provide Requirement information to the Service Design functional component if a Service Design functional component exists.
- Shall allow a Requirement to be traced to one or more Test Cases designed to test this Requirement if a Test functional component exists.
- Shall allow one or more Requirements to be associated to one or more policies that these Requirements originate from if a Policy functional component exists.
- Shall allow one or more Requirements to be traced to one or more Sources if a Source data object exists.
Data Architecture Criteria
The Requirement functional component:
- Shall allow recursive relationships between Requirements.
- Shall allow hierarchical relationships between Requirements.
- Shall associate a requirement to a service.
- Shall associate one or more Requirements to a single Logical Service if a Service Design functional component exists.
- Shall associate one or more Requirements to a Service Release that will fulfill these Requirements if a Release Composition functional component exists.
- Shall associate one or more Requirements to a Portfolio Backlog Item from which these Requirements originate if a Portfolio Demand functional component exists.
Model
Figure 48: Requirement Functional Component Level 2 Model
6.4.3 Service Design Functional Component
Purpose
Identify the new or existing services required to meet the needs of the Scope Agreement and IT Initiative, including both service systems and service offers. Leverage the Conceptual Service and Portfolio Backlog Items from the S2P Value Stream along with requirements to produce a Logical Service that describes the service structure and behavior considering both the service system and the service offer. Create various architectural artifacts (data flow diagrams, technical schematics, etc.) that comply with the IT Initiative specifications and boundaries. Create the service design specification document (Logical Service Blueprint). Identify the service delivery model (in-source, outsource, etc.). Identify service suppliers to meet the requirements within the chosen delivery model. Enable interaction with IT operations to develop support plan/requirements for an IT service. Ensure that the architecture and Logical Service Blueprint are compliant with all standards and policies, including security standards and policies. Ensure that the architecture and Logical Service Blueprint meet all requirements including security requirements to ensure the confidentiality, integrity, and availability of the service. Put instrumentation in place so that IT can capture empirical data about how IT services are performing rather than relying only on anecdotal input from the user community. Ensure that the service is architected to meet the KPIs and SLAs. The output of the Service Design functional component is used by the Source data object to source, create, and secure the service. The traceability is done through the Requirement functional component.
Key Data Objects
- Logical Service (data object): Represents the bridge between the service interaction and service system. It is a user-friendly name of the service system and is meaningful to the service provider, but may or may not be known specifically to the business. It represents the grouping of logical components necessary to provide the expected outcome or service interaction.
Auxiliary Data Objects
- Logical Service Blueprint (data object): Represents the design of the logical service which details the components and how those components relate to one another. There may exist multiple Logical Service Blueprints for a single Logical Service based on new versions of the Logical Service. Along with the Service Design data objects, the Logical Service Blueprint introduces the “how” details; i.e., technology delivery methods (on-premise versus cloud) and the technical interfaces necessary to access the service functionality.
Key Attributes
The Logical Service data object shall have the following key data attributes:
- Id: Unique identifier of the Logical Service.
- Name: Meaningful name of the Logical Service.
- Description: Short description of the purpose of the Logical Service.
- ConceptualServiceId: Unique identifier of the related Conceptual Service.
- BudgetedSpend: Approved budget for development of a service.
- ActualSpend: Actual spend for the development of a service.
The Logical Service Blueprint data object shall have the following key data attributes:
- Id: Unique identifier of the Logical Service Blueprint.
- Name: Meaningful name of the Logical Service Blueprint.
- Description: Short description of the purpose of the Logical Service Blueprint, to differentiate in case there is more than one for the Logical Service.
- Version: Version of the Logical Service Blueprint.
- LogicalServiceId: Unique identifier of the related Logical Service.
- ArchitectureDesign: An architectural representation (diagram) of the service system components.
Key Data Object Relationships
The Logical Service data object shall maintain the following relationships:
- Conceptual Service to Logical Service (1:n): One or more Logical Services represents the logical components which are necessary to provide the expected outcome of the Conceptual Service.
- Logical Service to Requirement (1:n): One or more Requirements will be used to define the required behavior from the Logical Service.
- Logical Service to Service Release (1:n): A Logical Service can lead to the creation of one or more Service Releases in order to deliver the required service outcomes.
- Logical Service to Logical Service Blueprint (1:1): A Logical Service structure and behavior can be detailed by one or more Logical Service Blueprints.
Functional Criteria
The Service Design functional component:
- Shall be the system of record (authoritative source) for all Logical Services.
- Shall identify the new or existing services required to meet the needs of the Scope Agreement and IT Initiative, including both service systems and service offers.
- Shall leverage the Conceptual Service and Portfolio Backlog Items from the S2P Value Stream along with Requirements to produce a Logical Service that describes the service structure and behavior considering both the service system and the service offer.
- Shall create various architectural artifacts (data flow diagrams, technical schematics, etc.) that comply with the IT Initiative specifications and boundaries.
- Shall create service design specification document (Logical Service Blueprint).
- Shall identify the service delivery model (in-source, outsource, etc.).
- May identify service suppliers to meet the Requirements within the chosen delivery model.
- Shall enable interaction with IT operations to develop support plan/requirements for an IT service.
- Shall ensure that the architecture and Logical Service Blueprint are compliant with all standards and policies, including security standards and policies.
- Shall ensure that the architecture and Logical Service Blueprint meet all Requirements, including security requirements, to ensure the confidentiality, integrity, and availability of the service.
- Shall put instrumentation in place so that IT can capture empirical data about how IT services are performing, rather than relying only on anecdotal input from the user community.
- Shall ensure that the service is architected to meet the KPIs and SLAs.
- Shall ensure output of the Service Design functional component is used by the Source data object to source, create, and secure the service.
- Shall ensure traceability is done through the Requirement functional component.
- Can receive the Conceptual Service specification and design several Logical Services that represent it if a Service Portfolio functional component exists.
- Shall receive the development spend from the Project functional component and pass it to the Service Portfolio functional component if a Service Portfolio functional component exists.
- Can receive IT Initiative information which includes the scope and some content based on which the service is designed if a Project functional component exists.
- Can receive Requirement information from the Requirement functional component used to design the Logical Service and create design specifications if a Requirement functional component exists.
Data Architecture Criteria
The Service Design functional component:
- Shall associate a Logical Service to a Conceptual Service.
- Can associate a Logical Service to a Logical Service Blueprint.
- Should track the actual spend of a Logical Service.
- Shall associate one or more Requirements to the Logical Service if a Requirement functional component exists.
- Shall associate one or more Logical Services to a Conceptual Service if a Service Portfolio functional component exists.
- Shall associate a Logical Service to one or more Service Releases which are detailed and designed to deliver the Logical Service if a Release Composition functional component exists.
Model
Figure 49: Service Design Functional Component Level 2 Model
6.4.4 Source Control Functional Component
Purpose
Develop source code or infrastructure based on the Logical Service Blueprint, Service Design Package, and IT Initiative priorities. Ensure that the source code meets the design specifications, organizational policies, standards, and non-functional requirements so that the service can be operated successfully and meets customer expectations. Manage the development backlog of Requirements and Defects in accordance with the Service Design Package and Service Release. Receive Defects and input from the Defect functional component to enable the development of fixes or documented workarounds. Create automated test scripts including unit testing and scripts for static application security testing that follow a formal software security assurance methodology. On existing services being changed, run security tests on core code to identify existing security issues at the start of the development cycle so that assessment of scope/requirements set/schedule can be negotiated early. Manage source code images and store them in a Source data object repository.
Key Data Objects
- Source (data object): The created or purchased solution to meet the requirements for a particular Service Release.
Note: Source does not always equal “source code”. Consider all use-cases such as “source code” for services produced on-premise, to contracts or entitlements for services simply subscribed to, to the purchase and implementation of a Commercial Off-The-Shelf (COTS) application.
Key Attributes
The Source data object shall have the following key data attributes:
- Id: Unique identifier of the Source.
- Version: Version of the Source.
- RequirementId: Identifier of the related Requirement(s).
Key Data Object Relationships
The Source data object shall maintain the following relationships:
- Source to Requirement (n:m): Source will fulfill one or many Requirements, and for a given Requirement, there could be multiple Sources created/modified.
- Source to Build (1:n): Source can be built multiple times to create several Build versions.
Functional Criteria
The Source Control functional component:
- Shall be the system of record (authoritative source) for all Source.
- Shall manage the lifecycle of the Source.
- Shall develop source code or infrastructure based on the Logical Service Blueprint, Service Design Package, and IT Initiative priorities.
- Shall ensure that the source code meets the design specifications, organizational policies, standards, and non-functional requirements so that the service can be operated successfully and meets customer expectations.
- Shall manage the development backlog of Requirements and Defects in accordance with the Service Design Package and Service Release.
- Shall receive Defects and input from the Defect functional component to enable the development of fixes or documented workarounds.
- Shall create automated test scripts including unit testing and scripts for static application security testing that follow a formal software security assurance methodology.
- Shall run security tests on core code to identify existing security issues at the start of the development cycle so that assessment of scope/requirements set/schedule for existing services being changed can be negotiated early.
- Shall manage source code images and store them in a Source data object repository.
- Can receive Defect information from the Defect functional component so that Defects can be fixed in future versions of that Source if a Defect functional component exists.
Data Architecture Criteria
The Source Control functional component:
- Shall allow recursive relationships between Source.
- Shall allow hierarchical relationships between Source.
- Shall associate Source to a service.
- Shall associate one or many Requirements to one or many Sources which includes the content that fulfills these Requirements if a Requirement functional component exists.
- Shall associate one or many Builds to the related Source if a Build functional component exists.
Model
Figure 50: Source Control Functional Component Level 2 Model
6.4.5 Build Functional Component
Purpose
Receive the Source data object from the Source Control functional component and manage the creation, implementation, automation, and security and storage of all Builds. Create Build from the Source data object for a particular service component. Automate the Build process to support the Build schedule and build frequency requirements in order to support daily Build and smoke test plans or continuous integration plans. Run dynamic application security testing no later than when the final Build data object is received and before the RFCs are created for moving the new or changed service into production. Manage Builds and versioning in a Definitive Media Library (DML). Develop automated Build storage procedures and automated compilation techniques and tools. Monitor and report on the results of each integration Build. Initiate or automate the delivery of Builds to the Build Package functional component for validation by the acceptance testing team as candidate release builds.
Key Data Objects
- Build (data object): Created from Source and versioned.
Key Attributes
The Build data object shall have the following key data attributes:
- Id: Unique identifier of the Build.
- Version: Version of the Build.
- SourceId: Identifier of the related Source.
- TestCaseId: Identifier of the related Test Case(s).
- BuildPackageId: Identifier of the related Build Package, after the Build Package is created.
Key Data Object Relationships
The Build data object shall maintain the following relationships:
- Source to Build (1:n): Source can be built multiple times to create several Build versions.
- Build to Test Case (n:m): One or many Builds can be related to one or many Test Cases used as part of the Build creation.
- Build Package to Build (1:n): A Build Package is comprised of one or many Builds.
Functional Criteria
The Build functional component:
- Shall receive the Source data object from the Source Control functional component and manage the creation, implementation, automation, and security and storage of all Builds.
- Shall create the Build from the Source data object for a particular service component.
- Shall automate the Build process to support the Build schedule and build frequency requirements in order to support daily Build and smoke test plans or continuous integration plans.
- Shall run dynamic application security testing no later than when the final Build data object is received and before the RFCs are created for moving the new or changed service into production.
- May manage Builds and versioning in a Definitive Media Library (DML).
- May develop automated Build storage procedures and automated compilation techniques and tools.
- Shall monitor and report on the results of each integration Build.
- May initiate or automate the delivery of Builds to the Build Package functional component for validation by the acceptance testing team as candidate release builds.
Data Architecture Criteria
The Build functional component:
- Shall be the system of record (authoritative source) for all Builds.
- Shall manage the version of each individual Build.
- Shall associate a Build to a service.
- Shall associate Source to one or many Builds if a Source Control functional component exists.
- Shall associate one or many Builds to one or many Test Cases which are executed as part of the Build creation if a Test functional component exists.
- Shall associate one or many Builds to a Build Package if a Build Package functional component exists.
Model
Figure 51: Build Functional Component Level 2 Model
6.4.6 Build Package Functional Component
Purpose
Create a deployable package made up of one or many Builds. Manage the Build Packages and relationships to the Service Release Blueprints.
Key Data Objects
- Build Package (data object): A compilation of one or many Builds in a deployable package.
Key Attributes
The Build Package data object shall have the following key data attributes:
- Id: Unique identifier of the Build Package.
- Name: Meaningful name of the Build Package.
Key Data Object Relationships
The Build Package data object shall maintain the following relationships:
- Build Package to Build (1:n): The Build Package is comprised of one or more Builds.
- Build Package to Service Release Blueprint (n:m): Multiple build packages, which represent the deployable content of the service components, can be deployed using the instructions contained in the Service Release Blueprints.
Functional Criteria
The Build Package functional component:
- Shall create a deployable package made up of one or many Builds.
- Shall manage the Build Packages and relationships to the Service Release Blueprints.
- Shall be the system of record (authoritative source) for all Build Packages.
Data Architecture Criteria
The Build Package functional component:
- Shall associate a Build Package to a service.
- Shall associate one or more Builds to a Build Package if a Build functional component exists.
- Shall associate one or more Service Release Blueprints to one or more Build Packages if a Release Composition functional component exists.
Model
Figure 52: Build Package Functional Component Level 2 Model
6.4.7 Release Composition Functional Component
Purpose
Manage the Release Package, Service Release, Service Release Blueprints, and overall Service Release for developing and delivering new or changed services to the R2F Value Stream Fulfillment Execution functional component to facilitate a smooth transition to IT operations. Create the Service Release, Service Release Blueprint, and Release Packages that will be utilized by the Test functional component and later the Fulfillment Execution functional component (R2F Value Stream) to create a specific deployment for a specific IT service instance (including service system and/or service offer). Begin the creation of monitors, batch processing, backup/restore, etc. for the service, to ensure supportability as part of IT operations enablement.
Manage the release artifacts within the Release Package by centralizing all elements of the Service Release Blueprint from the various functional components:
- Requirement functional component: Requirements per Release Package
- Source Control functional component, as well as maintenance scripts: documentation
- Build Package functional component: Build Package
- Test functional component: test results as well as automated tests for validation post deployment
- Defect functional component: Known Errors (issues/defects)
Key Data Objects
- Service Release (data object): Represents a planned release of a version of the service system. It relates to a single Logical Service. It represents the packaging of the service source and other key artifacts required to fully support the service system version, such as Requirements and Test Cases/scripts. It must contain a set of features that are sufficient to produce an outcome aligned to the value expectations of the offer.
- Service Release Blueprint (data object): Provides the planned design/configuration of the components of the service system. It contains the description and procedures in order to activate, deploy, and operate a service and its underlying components including applications and technology. May have many variations for a given Service Release as considerations such as environmental (development, stage, and production) or hosting (on premise or cloud) could be specified differently. Iterative development methods may re-use a Service Release Blueprint multiple times.
Key Attributes
The Service Release data object shall have the following key data attributes:
- Id: Unique identifier of the Service Release.
- Name: Meaningful name of the Service Release
- Status: Lifecycle status of the Service Release.
- Version: Version of the Service Release.
- LogicalServiceId: Unique identifier of the related Logical Service.
- ITInitiativeId: Unique identifier of the related IT Initiative.
The Service Release Blueprint data object shall have the following key data attributes:
- Id: Unique identifier of the Service Release Blueprint.
- Name: Meaningful name of the Service Release.
- Description: Description of the Service Release Blueprint.
- ServiceReleaseId: Unique identifier of the related Service Release.
- BuildPackageId: Unique identifier of the related Build Package.
- DefectId: Identifier of the related Defect(s).
- DeploymentModel: A representation of the deployable service components and their various configuration options.
Key Data Object Relationships
The Service Release data object shall maintain the following relationships:
- Logical Service to Service Release (1:n): A Logical Service can lead to the creation of one or more Service Releases in order to deliver the required service outcomes.
- IT Initiative to Service Release (1:n): An IT Initiative will manage the creation of one or more Service Releases defined to deliver the content of the IT Initiative.
- Service Release to Service Release Blueprint (1:n): A Service Release can be released to different environments based on different Service Release Blueprints.
- Service Release to Requirement (1:n): The Service Release describes a version of the service which fulfills one or more Requirements.
- Service Release to Test Case (1:n): A Service Release can be validated by one or many Test Cases/
The Service Release Blueprint data object shall maintain the following relationships:
- Service Release to Service Release Blueprint (1:n): A Service Release can be released to different environments based on different Service Release Blueprints.
- Service Release Blueprint to Build Package (n:m): Multiple Build Packages, which represent the deployable content of the service components, can be deployed using the instructions contained in the Service Release Blueprints.
- Service Release Blueprint to Desired Service (1:n): One Service Release Blueprint can be translated to one or more Desired Service(s).
- Service Release Blueprint to Fulfillment Request (1:n): One Service Release Blueprint is used for service instantiation by one or many Fulfillment Requests.
- Service Release Blueprint to Service Contract (n:m): One or more Service Release Blueprints contain the template of one or more Service Contracts.
- Service Catalog Entry to Service Release Blueprint (1:n): Each Service Catalog Entry is created based on definitions of a Service Release Blueprint.
- Service Release Blueprint to Defect (n:m): One or more Service Release Blueprints can contain one or more Defects in the form of Problems/Known Errors.
Functional Criteria
The Release Composition functional component:
- Shall be the system of record (authoritative source) for all Service Releases.
- Shall be the system of record for all Service Release Blueprints.
- Shall manage the Release Package, Service Release, Service Release Blueprints, and overall Service Release for developing and delivering new or changed services to the R2F Value Stream Fulfillment Execution functional component to facilitate a smooth transition to IT operations.
- Shall create the Service Release, Service Release Blueprint, and Release Packages that will be utilized by the Test functional component and later the Fulfillment Execution functional component (R2F Value Stream) to create a specific deployment for a specific IT service instance (including service system and/or service offer).
- May begin the creation of monitors, batch processing, backup/restore, etc. for the service, to ensure supportability as part of IT operations enablement.
Data Architecture Criteria
The Release Composition functional component:
- Shall associate a Service Release to a service.
- Shall allow a recursive relationship between Service Releases.
- Shall associate a Service Release to one or more Service Release Blueprints.
- Shall associate a Service Release Blueprint to a service.
- Shall associate a Service Release Blueprint to a Release Package.
- Shall associate one IT Initiative to one or more Service Releases which are defined to deliver this IT Initiative if a Project functional component exists
- Shall associate one Logical Service to one or more Service Releases which are designed to deliver this Logical Service if a Service Design functional component exists.
- Shall associate one Service Release with one or more Requirements which are fulfilled in this release if a Requirement functional component exists.
- Shall associate one Service Release with one or more Test Cases if a Test functional component exists.
- Can receive test-related information that should be included in the Release Package from Test Management if a Test functional component exists.
- Shall associate one or more Service Release Blueprints to one or more Build Packages if a Build Package functional component exists.
- Can receive one or more Build Packages that should be included in the Service Release Blueprint if a Build Package functional component exists.
- Can provide service contract information for creating a Service Contract if a Service Level functional component exists.
- Shall associate one or more Service Release Blueprints to one or more Service Contracts if a Service Level functional component exists.
- Can provide information required for service instantiation to the Fulfillment Execution functional component if a Fulfillment Execution functional component exists.
- Shall associate a Service Release Blueprint to one or more Desired Services if a Fulfillment Execution functional component exists.
- Shall associate a Service Release Blueprint to one or more Fulfillment Requests if a Fulfillment Execution functional component exists.
- Can provide information required for creating a Service Catalog Entry to the Catalog Composition functional component if a Catalog Composition functional component exists.
- Shall associate a Service Release Blueprint to one or more Service Catalog Entry(ies) if a Catalog Composition functional component exists.
- Shall associate one or more Service Release Blueprints to one or more Defects if a Defect functional component exists.
- Can receive Defect-related information that should be included in the Release Package if a Defect functional component exists.
Model
Figure 53: Release Composition Functional Component Level 2 Model
6.4.8 Test Functional Component
Purpose
Trace to Requirements. Plan and execute tests that ensure the IT service will support the customer’s requirements at the agreed service levels. Create Defect data objects that are consumed by the Defect functional component. Plan and design tests, including automated test scripts for both code images and monitors, using input from service development. Prepare the test environment. Execute tests, including functionality, usability, acceptance, risk-based security (dynamic application security and infrastructure security testing), performance, and stress testing. Create Defects found during testing which are consumed by the Defect functional component. Manage test data, drive automation, and re-use test automation and test scripts where appropriate. Provide test execution reports for the tested Requirements. Ensure that the operations tooling works as expected (monitors, etc.).
Key Data Objects
- Test Case (data object): The Test Case is used to validate that the Service Release is fit for purpose.
Key Attributes
The Test Case data object shall have the following key data attributes:
- Id: Unique identifier of the Test Case.
- Name: Meaningful name for the Test Case.
- Description: Summary or short description of the Test Case.
- Status: Lifecycle status of the Test Case.
- Result: Last known Test Case execution outcome.
- ServiceReleaseId: Unique identifier of the related Service Release.
- RequirementId: Identifier of the related Requirement(s).
Key Data Object Relationships
The Test Case data object shall maintain the following relationships:
- Requirement to Test Case (1:n): A Requirement is associated to one or more Test Cases that validates this Requirement.
- Service Release to Test Case (1:n): A Service Release is associated to one or more Test Cases which are executed as part of this Service Release.
- Test Case to Build (n:m): One or more Test Cases can be associated with one or more Builds that uses this Test Case as part of the Build creation.
- Test Case to Defect (1:n): One Test Case can be associated to one or more Defects that are reported as a result of this test.
Functional Criteria
The Test functional component:
- Shall ensure traceability between tests and Requirements.
- Shall plan and execute tests that ensure the IT service will support the customer’s requirements at the agreed service levels.
- Shall create Defect data objects that are consumed by the Defect functional component.
- Shall plan and design tests, including automated test scripts for both code images and monitors.
- Shall leverage input from service development.
- Shall prepare test environments.
- Shall execute tests to include:
— Functionality tests
— Usability tests
— Acceptance tests
— Risk-based security tests (dynamic application security and infrastructure security testing)
— Performance tests
— Stress tests
- Shall create Defects found during testing which are consumed by the Defect functional component.
- Shall manage test data.
- Shall provide test execution reports per tested Requirements.
- Shall ensure follow-on value stream functionality works as expected (service monitors, service provisioning, etc.).
- Shall be the system of record (authoritative source) for all Test Cases.
- Shall manage the lifecycle of the Test Case.
- May drive automation.
- May ensure test automation re-use and test scripts.
Data Architecture Criteria
The Test functional component:
- Shall allow recursive relationships between Test Cases.
- Shall associate a Test Case to a service.
- Shall associate one or more Test Cases to one or more Builds that uses this Test Case as part of the Build creation if a Build functional component exists.
- Shall associate a Requirement to one or more Test Cases that validates this Requirement if a Requirement functional component exists.
- Shall associate a Test Case to one or more Defects that result from this test if a Defect functional component exists.
- Shall provide Defect information to the Defect functional component if a Defect functional component exists.
Model
Figure 54: Test Functional Component Level 2 Model
6.4.9 Defect Functional Component
Purpose
Keep track of all Defects; including their origin, status, importance, and relation to Requirements and Known Errors. Register Defects of all types (including security-related) with all relevant details such as description, severity, application version, related requirement, etc. Analyze Defects and find resolution. Associate Defects with Requirements. Document issues that should be communicated to the Release Composition functional component. Consume Defects from the D2C Value Stream Problem functional component as well as the Test functional component that are in turn consumed by the Source Control functional component for review and resolution. Update Defect details. Decide on target release. Report Defect status and provide Defect reports. Convert Defects not resolved by service development to Known Errors for Problem Management (D2C Value Stream) to document or develop work-around and report in knowledge management articles.
Key Data Objects
- Defect (data object): An issue with the Service Release Blueprint which should be remediated to fulfill the associated Requirements.
Key Attributes
The Defect data object shall have the following key data attributes:
- Id: Unique identifier of the Defect.
- Title: Short description of the main issue discovered.
- Description: Description of the Defect.
- Status: Status of the Defect.
- TestCaseId: Identifier of the related Test Case.
Key Data Object Relationships
The Defect data object shall maintain the following relationships:
- Test Case to Defect (1:n): One Test Case can be associated to one or more Defects that results from the test.
- Defect to Service Release Blueprint (n:m): One or more Service Release Blueprints are associated to one or more Defects which are included in the Release Package as Problems/Known Errors.
- Known Error to Defect (1:1): A Known Error may be the source for submitting a new Defect.
- Incident to Defect (1:1): A current practice that replaces the Known Error path when that one does not exist. An Incident may be the source for submitting a new Defect.
Functional Criteria
The Defect functional component:
- Shall be the system of record (authoritative source) for all Defects.
- Shall manage the lifecycle of the Defect.
- Shall keep track of all Defects; including their origin, status, importance, and relation to Requirements and Known Errors.
- Shall register Defects of all types (including security-related) with all relevant details such as description, severity, application version, related requirement, etc.
- Shall analyze Defects and find resolution.
- May document issues that should be communicated to the Release Composition functional component.
- May consume Defects from the D2C Value Stream Problem functional component as well as the Test functional component that are in turn consumed by the Source Control functional component for review and resolution.
- May update Defect details.
- May decide on target release.
- Shall report Defect status and provide Defect reports.
- Shall convert Defects not resolved by service development to Known Errors for Problem Management (D2C Value Stream) to document or develop work-around and report in knowledge management articles.
- Shall receive Defect information from the Test functional component if a Test functional component exists.
- Shall receive Defect information from a Known Error if a Problem functional component exists.
- Can provide Defect information to the Source Control functional component if a Source Control functional component exists.
Data Architecture Criteria
The Defect functional component:
- Shall associate a Defect to a service.
- Shall associate Defects with Requirements.
- Shall associate one or more Service Release Blueprints to one or more Defects which reflects Defects that should be published as Problems/Known Errors if a Release Composition functional component exists.
- Shall associate a Test Case to one or more Defects if a Test functional component exists.
- Shall associate a Known Error to a Defect if a Problem functional component exists.
Model
Figure 55: Defect Functional Component Level 2 Model