What is an Agile Process Improvement?

A process improvement program is successful only when the meaning of the word ‘process’ is clearly understood. Process means work. So when one improves, the other one also improves. The quality of the software depends a lot on the process. Whenever a change is introduced, a temporary drop in performance is always recorded. In most cases what happens is that the organization stops the implementation of changes fearing the disruption in the normal work since so much effort is required. To avoid such situations, the changes need to be adaptive. It is the agile process improvement that makes this possible. You might say that such a way of iterative improvement is not new. Well, the agile techniques introduce discipline in the whole program.

Stages of Agile Process Improvement

The following are the stages of the agile process improvement:

1. Initiating:

Ø  Stimulus of change

Ø  Set context

Ø  Build sponsorship

Ø  Charter infrastructure

2. Diagnosing:

Ø  Characterize current and desired states

Ø  Develop recommendation

3. Establishing:

Ø  Set priorities

Ø  Develop approach

Ø  Plan actions

4. Action:

Ø  Create solution

Ø  Test solution

Ø  Refine the solution

Ø  Implement solution

5. Learning:

Ø  Analyze

Ø  Validate

Ø  Propose future actions

- The improvement cycles are meant to be followed systematically so that the results might be obtained in time ranging from 2- 6 weeks.

- The whole process lets you maintain a balance the workload as well as the improvement. 

- The flow of the process is as follows:

1. Prioritized list of improvements
2. Detailed plan for the current cycle
3. Implemented improvement
4. Feedback

- After this process, the following becomes possible for the organization:

1. Identification and resolving of the issues earlier in the cycle.
2. Learning process regarding how to tackle difficulties and working of this process.
3. Adaption to the business needs that keep changing.
4. Giving response to the feedback.

- The sponsor holds the responsibility for prioritizing the improvement backlog at the start of each sprint. 

- Also, he is the one responsible for ROI. 

- Prioritization is a good tool for the sponsor to direct the change. 

- Using prioritization, the goals and feedback can be revised from quality assurance. 

- A focus can be kept on the benefit received from each improvement cycle. 

- PPQA deploys and evaluates the improvement in organization in every sprint. - The improvement package consists of 4 sprints namely:

1. Prototyping
2. Piloting
3. Deploying
4. Evaluating

- Active participation and leadership is required for a change to take place. 

- An endorsed vision and status quo is required for the beginning of the process. 

- Both of these are established via SCAMPI and CMMI. 

- The change is led by the management on an everyday basis.

- An excellent description is provided by the generic practices of CMMI for the leadership purpose.

- Similarly participation is a key element that is facilitated by the change team. - A vision is required for initiating the improvement project. 

- The initial improvement backlog is defined by 3 things namely scrumMaster, change team and the work owner i.e., the sponsor all based up on an assessment. 

- The organization is facilitated by the change team.

- With each sprint a tangible improvement is delivered. 

- The change is led by the management in a sprint.

- The effect introduced by the change is evaluated at the end of each sprint by PPQA. 

-The new improvements are defined by the work-owner who is also responsible for adding those in to the backlog of improvements and prioritizes it.

-Commitment is supported at the end of the sprint by appraisal.

-The improvements can also be continuously integrated in to the organization’s way of working. 

What is a Test Object Model in QTP?

Test object model is an important concept of quick test professional to be understood. In this article we have focused on the test object model of the quick test professional itself. 

What is a Test Object Model?

- The test object model is considered to be a large set of classes or objects of type class which are used by the quick test professional to represent the objects present in the software system or application.

- There is a list of properties associated with every class of the test object. 

- Using the properties from this property list, the objects belonging to that particular class can be uniquely identified. 

- Also, the identification of a set of relevant methods that can be recorded for the object by the quick test professional can be easily identified. 

First let us clear up few terms associated with the test object model one by one:

1. Test object: 

This is the object that is created by the quick test professional in the test component or the test as a means of representation of the actual object present in the AUT or application under test. The information regarding the object is stored by the quick test professional since later it is required for many purposes like identification of the object and checking the working of the object during the run session.

    2. Run time object: 

   This object is the actual object present in the application under test. On this object only the various methods are performed while the identification process is in progress or we can say during the run session.

Whenever the user carries out an operation on an object in the application, the  following steps are taken by the quick test professional:

a)    Identification of the test object class of the quick test professional which is said to represent the object up on which the user performed the desired operation.

b)   Creation of appropriate test object based up on the identification in the previous step.

c)     Capturing of the current values of the properties of the objects residing in the application under test and preparing a list accordingly. This list is then saved along with the test object.

d)   Giving of a unique name to the test object up on the condition that it should reflect the value of one of the objects prominent properties.

e)    Recording of the operations that the user carried out on the test object by making use of the appropriate quick test professional test object method.

There are certain points about the test object model which are always helpful:

1. Each and every test object method that is executed during the recording session forms a separate step in the recorded test. When the command for execution of the test is encountered, this recorded test object method is played up on the run time object.
2. The source from where the properties of the object are captured is the object itself. These properties are important since there values are used for the identification of the run time objects while a run session is in progress.
3. The properties of the objects have a tendency to change during the run session and so this would present some difficulty while matching the objects with the description. To avoid such a situation you have the option to make a manual modification of the test object properties while designing the test component during a run session. Some times even the regular expressions can be used as a substitute for the identification of the property values.
4. The test object property values can be viewed as well as modified and stored through the object repository dialog box. 

How does QTP recognize Objects in AUT?

The quick test professional comes with two types of object identification mechanisms unlike winrunner as mentioned below:

1. Usual or the normal object identification mechanism and
2. The smart identification mechanism

What is Usual or Normal Object Identification Mechanism

- In the usual object identification routine, the first step of the quick test professional is to learn the description of the object as provided by the user before the starting of the test. 

- The description of the object provided by the user consists of the properties of the object. 

- All the objects present in the software system or AUT (application under test) are matched one by one with this physical description.

- It is checked that how many properties of the object are matching with the properties mentioned in the description. 

- This method is the easiest  of the two above mentioned object identification routines. 

Now what if this usual object identification mechanism fails to identify the object? 

The alternative here is the second object identification mechanism i.e., the smart identification mechanism. 

Why does a the normal method fails?

- The normal method fails because the value of the object properties starts changing dynamically which makes it difficult for the quick test professional to track the object. 

- Another situation in which the normal identification mechanism can fail is when the quick test professional finds not one but more than one objects in the application under test matching with the properties mentioned in the description. 

- In such a case the quick test professional erases from its memory the learnt description of the object and calls up on the smart identification mechanism for the identification of that particular object. 

Let us see a comparison between the smart identification mechanism and the normal identification mechanism:

1. Smart identification is more complex then the usual one.
2. Smart identification is more flexible then the usual one.

What is Smart Identification Mechanism

- Smart identification mechanism is so reliable that it can work even if the currently provided description of the object fails.

- To get the best out of the smart identification mechanism, one needs to configure it properly in a logical way. 

- Smart identification mechanism is driven by two different sets of properties as described below:

1. Base filter properties: As the name suggests these are the base or the fundamental properties belonging to a particular test object class. The value of these fundamental properties cannot be changed until and unless you make changes in the properties of the original object.
2. Optional filter properties: The leftover properties i.e., all the properties leaving out the base filter properties are grouped under this category i.e., the optional filter properties. These properties unlike the other base filter properties do not change frequently. These properties can some times be ignored i.e., when they do not hold to be applicable and therefore have been named as optional filter properties.

How the smart identification process follows?

- The description given by the user is erased from the memory of the quick test professional and a list of objects called candidate list is created.

- Objects or candidates in this list match at least one property in the property list. 

- Now, the base filter properties are used for cutting down on the list of the object candidates. 

- The list is narrowed down to only one object which has most number of properties matching in the list of properties. 

- Some times it may happen even after reaching this stage the quick test professional may not find a matching object. 

- In such a case the quick test pro makes use of an ordinal identifier in addition with the learnt description. 

Explain the concept of object repository & how QTP recognizes objects?

Just like its Winrunner counterpart, the quick test professional also comes with an object repository which is the first aspect of this article that we are going to discuss in this article and the second aspect to be discussed is regarding the identification of the objects by the quick test professional. 

What is a Object Repository?

- Just like we have a store room and other storage places in our house, the same way the quick test professional consists of a storage place where the information regarding the objects can be stored and this storage place is called the “object repository”. 

- During the process of the identification of the objects, the presence of an interface is necessary between the application under test and test scripts in order for proper identification of the objects. 

- This interface is provided by none other than the object repository itself. 

- An object can be identified as a run time entity with some characteristic properties as well as structure. 

- Few examples of software objects are:

1. Windows
2. Web pages
3. Edit boxes
4. Buttons
5. Check boxes and so on.

What kind of objects QTP recognizes?

Quick test professional recognizes 4 types of objects as mentioned below:

1. Run time objects

These are the objects that are present in the application under test or AUT such as links, check boxes, buttons etc.

2. Test objects

-Run time objects cannot be operated up on directly rather there references are created which are nothing but the test objects such as web button, link, win edit and so on. 

-These test objects are referenced by different names in different environments.

3. Utility Objects

- These are the objects that are reserved by the quick test professional for the purpose of testing as well as test reporting. 

- One such example is the reporter object for displaying the test results.

4. User defined objects (also known as the automation objects)

- In most of the cases objects are required that can perform some specific operations i.e., the user defined operations. 

- Such objects are referred to as the user defined objects.

How QTP recognizes objects?

- For every action that is performed on an object, a local repository is created by the quick test professional automatically while the recording is in progress.

- The local object repository is different from the global object repository in the respect that it cannot be shared among the tests.

- Additional objects can be added to this repository by the user as well as the existing ones can be modified. 

- Global object repository is more commonly known as the shared repository. 

Now let us focus up on the second aspect of the quick test professional i.e., the identification of the objects. 

- Quick test professional has got two major mechanisms for accomplishing this task as stated below:

1. Usual object identification mechanism

- In this mechanism, the learned description of the object i.e., the one provided by user is followed throughout the identification process for identifying the object. 

2. The smart identification mechanism

- This mechanism is smarter than the former one, more flexible but far complex. 

- It comes into play when the first one fails. 

- It rejects the description that was used in the first mechanism and prepares a list of objects that resembles properties defined by the quick test professional. - For the smart identification process to work properly it is required that it should be configured properly. 

What is smart Identification in QTP?

Smart identification mechanism is one of the most important and effective mechanisms of the quick test professional. Usually for the identification of an object the quick test professional goes around the usual i.e., the normal identification process.

But what the quick test professional is supposed to do when this usual object identification routine fails? At this point the smart identification mechanism of the quick test professional comes to the rescue of the testers.

Smart Identification in QTP

- The smart identification mechanism has got many positive attributes.

- It is more flexible and works with more efficiency for the identification of the difficult objects present in the application that cannot be found with the normal identification mechanism. 

- But for the smart identification to work, it is required that you enable this option in the object identification settings. 

- Smart identification mechanism works up on two types of properties as mentioned below:

1. Base filter properties and
2. Optional filter properties.

- The first category of the properties i.e., the base filter properties constitute of the most fundamental properties pertaining to a particular class of test object. 
- The values of the properties falling in this category cannot be changed or altered without changing the same properties in the original object.
- The second category of the properties i.e., the optional filter properties consists of the other properties that contribute in the identification process of the objects. 
- In the process of smart identification of an object, the quick test professional first erases from its memory the learnt description or the description that was entered by the user in to the physical description field of the object. 
- Instead of this single object, a list of matching objects (in this case such objects are called candidates) is created by the quick test professional called the candidate list. 
- This list is created based up on the properties that have been defined in the category of base filter properties and thus all the objects match a little or lot (i.e., to say one or more properties) with the base filter properties. 
- Base filter properties as the name suggests are the major properties that help cut down or reduce the number of objects in the candidate so that an exact match can be found or we can say that the area of search is reduced. 
- The idea is to be left with only one object matching with most or all of the properties mentioned in the saved description. 
- In some cases it may happen that it may be required to invoke smart identification mechanism during the run session. 
- In such cases a warning message is generated by the test results tree which indicates about the invocation of the smart identification and insertion of a smart identification process. 
- It is said that the smart identification is applicable only for the web based applications. 
- The object is recorded from the AUT or application under testing and its properties are identified accordingly and finally the scripts are executed. 
- Some times you may receive a warning alert in the results of the tests. 
- You just need to navigate over this message in the file which stores the messages and read what it says and follow accordingly. 
- Usually the normal identification routine fails whenever there occurs a dynamic change in the properties of the object to be identified. 
- Because of such dynamic changes the value of the object properties keep on changing thus making it difficult for the quick test professional to track that particular object. 
- These dynamic changes are shown only in the result and are not stored in the local object repository and are accessible only for the run  time. 

How does QTP identifies objects?

Just like winrunner the process for identification of objects is same for quick test professional. In Winrunner, it is required that the winrunner learns about all the objects before it begins identifying them. After learning about the entire GUI objects present in the software system or application the quick test professional begins its search regarding the object or objects that seem to be matching with the properties as stated by the user in the description of the objects.

In many of the cases the description of the objects proves to be quite a useful and simplest method for the identification of the GUI objects residing in the software system or application. This mechanism of quick test professional of searching the objects is bound to work until and unless the properties of the GUI objects are changed. In some cases it happens that the quick test professional encounters two situations;

1. It does not proves successful in the identification of the object that is suppose to match with the description given by the user or
2. It finds more than two objects having the same description as stated by the user.

In the above two situations the quick test professional adopts another mechanism and rejects the usual way of object identification. This new mechanism is quite advance then the usual one and is thus known as the smart identification mechanism.

Smart Identification Mechanism for objects in QTP

- This smart identification mechanism being smarter than the normal mechanism is also more complex than that. 

- Even though it is more complex it is more flexible also.

- If the smart identification mechanism is configured according to proper logic then there are possibilities that the quick test professional may be able to identify the GUI objects even if the description provided by the user fails. 

- There are 2 basic properties that are unique to the smart identification mechanism of the quick test professional:

1. Basic filter properties: These properties represent the basic fundamental properties of the test object class. The values represented by these properties cannot be changed or replaced without making proper changes to the original object values.
2. Optional filter properties: These are the properties apart from the basic filter properties which also help in the identification of the GUI objects belonging to a particular test class. Unlike the basic filter properties, the optional filter properties do not change on a regular basis. Still these properties can be ignored if they no longer hold to be applicable.

When is Smart Identification Mechanism Activated by QTP?

The smart identification mechanism is activated by the quick test professional only when its unable to identify some object and the whole process is carried out through the following steps:

1. The quick test professional erases the learnt description of that particular object from its memory and creates a new list of the object candidates that fall under that particular parent object. The objects mentioned in this candidate list are the ones whose properties have a match with the properties in the list of the base filter properties.
2. The object in the candidates list is matched one by one with the properties listed in the base filter property list and if the no match is found that particular object candidate is simply rejected. The leftover object candidates in the list constitute a new candidate list.
3. When the list gets empty for one property, the previous candidate list is again adopted by the quick test professional and is considered for matching with the second property.
4. If only one object remains in the candidate list then this object is considered to be the required one. 

How will you handle Java tree in QTP?

In this article we shall talk about how to handle java trees in quick test professional. But first let us see what a java tree actually is.

What is a Java Tree?

- Java tree is a data structure unique to java which can be used to display hierarchical data. 

- Java tree does not essentially holds or stores data rather it just provides the user with a view of the data i.e., in the way the data has been actually organized in the software system or application.

- The java tree obtains all this data by generating queries to the data model just like any other non- trivial swing component. 

- The data in a java tree is represented in a vertical manner. 

- Each row in this vertical representation displays only one data item called a node. 

- Each java tree has got it roots in the root node and this is from where all the branches of the tree descend. 

- In the default mode, the root node of a java tree is automatically displayed but this view can be modified. 

- The branch nodes are also referred to as children.

- The branch nodes can be expanded and collapsed as required. 

- Identification of a specific node in the tree can be done via a tree path. 

- A tree can be thought of as a container class that consists of elements of the type node. 

- These node elements can be thought of as thin cover over the actual data which has to be assigned some generic type. 

- These nodes cover the actual data which has to be represented by the means of a hierarchical data structure i.e., nothing but the java tree. 

- The java trees don’t become useful on their own. 

- They become useful when one can store and retrieve some tasks via them from the data base of the application.  

- Java trees are the one kind of the data structures which can represent the data in its true hierarchical manner. 

- It is possible for a node not to have any children whereas in other cases a node may have a large number of children and such nodes are referred to as branch nodes.

How to handle Java tree in QTP?

Java trees have a place in quick test professional also and now we going to discuss how to handle one. 

- For handling a java tree in quick test professional it is required that a java add–in is installed in the quick test professional. 

- In the tools menu there is one drop down list available by the name of “object identification”. 

- In this drop down list you will get one option “java” which facilitates the recognition of the objects. 

- Now from this drop down list select the tree option. 

- All you have to do is to add the properties that you want to be identified. 

- Just after doing this the quick test professional will be able to recognize the java tree. 

- If not this way you can even use DOM for the same purpose. 

- Here what you need to do is to make an appropriate code selection from the back ground and have it modified accordingly. 

- Another way can be to first select the option “JavaAdd” and then launch the quick test professional. 

- Your next step will be to record all the operations that are being performed up on the java tree. 

- If you face any problem with this way then you can try going back to the java tree object properties and modify the assistive and mandatory properties for easy identification. 

- You may face some difficulty while trying to expand all the nodes of the java tree even by using expandpath and expandrow commands.  

What is QTP? What are the types object Repositories in QTP?

HP has set out a new margin in the field of test automation by introducing the quick test professional. This test automation suite has a dedicated efficiency towards the automation of functional and regression testing scripts for testing software system, applications as well as environments.

There is no doubt that the quick test professional is from the family of HP quality center tool suite and can be very well used for enterprise quality assurance. 

What is Quick Test Professional (QTP)?

- A very user friendly graphical user interface is what that makes the quick test professional quite amiable with the users. 

- It provides extensive support for keyword and interface scripting.

- The language that is used here for manipulating the controls and objects present in the application and setting out the specifications for a test procedure is the VBScript or visual basic scripting edition. 

- The original writer of the quick test professional is mercury interactive itself as it was for the other HP products. 

- The current version of the quick test professional version 11.0 has been made available via the HP software division. 

- This present version of quick test professional has proved to be the most reliable as well as the stable version among the rest of the versions. 

- Till now 12 versions of quick test professional have been released out of which there was a version 7.0 which was never released. 

- Quick test professional can be called as a complete test automation tool than a test automation suite. 

- It mainly operates on the Microsoft windows operating system. 

- This test automation tool comes with a proprietary license. 

- The quick test professional can even test the test the testing environments unlike the previous test automation tools which could only test the software systems and applications. 

- It helps a great deal when it comes to the identification of the objects in a web page or an application user interface and can even perform desired user – interface interactions. 

- The quick test professional has been developed by HP especially for UI based test case automation but it can also be extended to automate some of the non UI based test cases such as those mentioned below:

1. File system operations
2. Web services testing
3. Data base testing and so on.

- It is cent percent correct to say that the quick test professional is the true successor of winrunner. - In some of the cases it may happen that the HP quick test professional may not identify some of the complex as well as other customized user interface objects. 

- These objects have to be defined by the users as virtual objects. 

- However, there is no support provided by HP low level mode recording or analog recording of the virtual objects. 

Types of Object Repository of QTP

Now let us discuss regarding the object repository of the quick test professional. 

- An object repository can be thought of as a store room of quick test professional where it stores all the information regarding the objects. 

- The object repository also enacts as an interface between the AUT and test script in order to facilitate the identification of the objects during the execution process. 

- In QTP objects are classified in to following 4 categories:

1. Test objects
2. Utility objects
3. Run time objects
4. User defined objects or automation objects

- A local object repository is also created by quick test professional automatically for each and every action when the recording is in progress. 

- These local repositories cannot be shared among different tests. 

- However, they can be supplemented by additional objects by the user. 

- Operations like insertion, deletion and renaming can be performed by the user on the objects present in the local repository. 

Eliciting Requirements - what are basic requirements for Quality Function Deployment ? PART 2

Quality function deployment defines requirements in a way that maximizes the customer satisfaction. Quality function deployment is used to translate customer requirements to engineering specifications. It is a link between customers, design engineers, competitors and manufacturing. QFD is important as it gives importance to the customer and put these values in engineering process. There is a proper time to use quality function deployment. It is used in early phases of design. It can also be used as a planning tool as important areas are identified.

Quality function deployment contains four phases:
- product planning
- product design
- process planning
- production planning

The benefits of QFD includes better understanding of customer needs, reduces iterations in design and enhancing teamwork. There are three types of requirements that are defined by QFD:
- Normal requirements are a mirror of objectives that are stated for a product during meetings with the customer. Normal requirements include graphical displays,specific system levels.
- Expected requirements are requirements that are fundamental and customer does not explicitly state them but their absence will create a significant dissatisfaction. These include ease of software installation and human/machine interaction etc.
- Exciting requirements are the requirements that do not fall within customer's expectations but are very satisfying when they are present.

Eliciting Requirements - what are basic guidelines for conducting collaborative requirements gathering meeting? PART 1

For collaborative requirements gathering, stakeholders and developers work together to identify the problem, propose a solution and negotiate approaches. The basic guidelines include:
- software engineers and customers attend meetings.
- rules for preparation and participation are established.
- agenda that covers important points and encourage free flow of ideas.
- meeting is controlled by a facilitator who can be a customer, developer or an outsider.
- worksheets, wall stickers, chat room etc. are used.
- goal is to identify the problem, propose a solution and negotiate approaches.

If a system or product will serve many users, one should be certain that requirements are elicited from representative cross-section of users. If only one user defines all requirements, acceptance risk is high. As requirements gathering meeting begins, the first point of discussion is need and justification of the new product. Once agreement is established, each participant presents his lists for discussion in one particular area. After this, combined list is prepared by group after which facilitator coordinates discussion.
Avoid the impulse to shoot down a customer's idea as "too costly" or impractical. The idea is to negotiate a list that is acceptable to all.

Once the lists are completed, team is divided into sub teams and each works to develop mini specifications. Additions, deletions and elaborations are made. After this, each attendee makes a list of validation criteria and finally one or more participant is assigned the task of writing a complete draft specification.

What is Software Project Management? List the number of tasks it consists.

In Software Project Management, the end users and developers need to know the length, duration and cost of the project. It is a process of managing, allocating and timing resources to develop computer software that meets requirements. It consists of eight tasks:
- Problem Identification
- Problem Definition
- Project Planning
- Project Organization
- Resource Allocation
- Project Scheduling
- Tracking, Reporting and Controlling
- Project Termination

In problem identification and definition, the decisions are made while approving, declining or prioritizing projects. In problem identification, project is identified, defined and justified. In problem definition, the purpose of the project is clarified. The main product is project proposal.

In project planning, it describes a series of actions or steps that are needed to for the development of work product. In project organization, the functions of the personnel are integrated. It is done in parallel with project planning.

In resource allocation, the resources are allocated to a project so that the goals and objectives are achieved. In project scheduling, resources are allocated so that project objectives are achieved within a reasonable time span.

In tracking, reporting and controlling, the process involves whether the project results are in accordance with project plans and performance specification. In controlling, proper action is taken to correct unacceptable deviations.

In project termination, the final report is submitted or a release order is signed.

What is Software Testing? What are its goals and principles?

Software testing is a process to detect the defects and faults before it is given to the end-users. The goal of software testing is to identify them.
- Fault Identification is the process of identifying the cause of failure; they may be several.
- Fault Correction and Removal is the process of making changes to the software and system to remove the fault.

The main objectives of software testing are:
- To design a test case with high probability of finding undiscovered bugs.
- To execute the program with the intent of finding bugs.

The principles of software testing are:
- As part of traceability analysis, every test should be able to be raced back to the requirements.
- Test should be planned long before testing begins.
- Testing should begin “in small” and progress toward testing “in the large”.
- An independent third party should conduct the test.

Software Testing Strategies integrate software test case design methods into a well planned series of steps that result in the successful implementation of the software.
A test specification is developed by the leader of quality assurance group. A Test Specification is an overall strategy that defines the specific tests that should be conducted.
Software testing begins from a single component using white-box and black-box techniques to derive test cases. Once the class is tested, integration of the class through communicationand collaboration with other tested classes is tested. The main goal is to uncover as many errors as possible.

Requirements Traceability Matrix (RTM) - A tool for managing requirements

The Requirements Traceability Matrix is a tool for managing requirements. It is not only used in requirements engineering but through out the software engineering process. The white box approach refers to the development of system requirements without
considering the technical implementation of those requirements.

Components of Requirements Traceability Matrix

- RTM ID: A unique identification number for a specific requirement.
- Requirements: This is a structured sentence describing the requirements in a "shall" format.
- Notes: These are additional notes of requirements.
- Requestor: This is the person who requested the requirement.
- Date: This is the date and time the requirement was requested by requestor.
- Priority: This is the priority given to the requirements.

While the above elements are the initial RTM, one can customize the matrix to tie the requirements with other work products or documents. It can be done by:

- Relative to RTM ID: It specifies if the current RTM is directly or indirectly related to other requirements.
- Statement of Work (SOW): This is a description that relates the requirements directly back into a specific paragraph within the Statement of Work. It is a document that specify the nature of the engagement of the development team with their clients.

The components and the use of the RTM should be adapted to the needs of the process, project and product. It grows as the project moves along.