Our development process varies according to the service models desired by the client. However, all our processes strictly adhere to quality guidelines we have adopted from the beginning and fine-tuned over the years. Below is a brief description of a typical project life-cycle, from inception to implementation.

Initial discussions and agreement:

The first step starts with Pyxisnet receiving high-level requirements of the project. A rough estimate of project timeline and costs are then provided to the prospective client. This could lead to a request for proposal from us or this step may be skipped in favor of further discussion conducted verbally and via emails. If the discussions are favorable it would result in the signing of an agreement for either a specifications gathering phase or for the project itself.

Requirements Management:

After the contract is signed the initial requirements are then further gathered from the client through documentation and customer interviews. The final User Requirements is generated, signed-off and forms the basis for the project foundation. The requirements are then analyzed in preparation for further estimates and design activities.

During the requirements phase the Quality Assurance (QA) team members are involved in testing the requirements for validity, consistency, completeness, etc.

Design:

Requirements analysis is followed by design. The design is usually done in two stages: high level and detailed level. The High Level design uses the User Requirements to derive the system architecture, application framework, interfaces, functional decomposition, dependencies, object design (excluding detailed descriptions), etc. The units, arrived at during the High Level Design decomposition, are further detailed in our formatted Detailed Design document. Detailed design includes details of the application framework, usage of architecture, object and class descriptions, etc.

During this phase the QA team starts the development of test cases which continue on while the development team is coding (next phase).

Coding:

Detailed Design documents are used for writing code and unit testing modules. PyxisNet has developed its own coding standard (including naming convention) which is typically followed unless the client has its own coding standards and desires that be followed. The code is then reviewed by senior developers to ensure its quality after certain iterations.

During the code development phase some design changes may be required which is also managed by the change control mechanism.

Software Integration and development testing:

Unit tested code is integrated together periodically to obtain sub-systems and the system. Sub-system and system testing is performed by our separate testing team. The focus is to verify and validate the functioning of the sub-systems and system and also to perform the test cases developed earlier. During testing the test cases are further refined and bugs reported through our bug tracking tool.

Test phases:

Once development is considered concluded the product is then handed over to the QA team for verification and testing phases. Typically the phases consist of Final Integration Testing, System Testing and Pre Acceptance Testing. The tests are conducted through a mixture of manual tests and using automated test tools such as VSTS, imacro.

Product Support Documentation:

During the testing phase various supporting documents are developed according to the client requirements. These are typically user manuals, installation and configuration manuals.

Installation, Acceptance and Changeover:

The system is then installed at client site (if required) and the client performs the agreed upon acceptance testing to accept the system and puts the accepted system in operation.

Maintenance and Support:

With the system up and running, the maintenance and support phase starts. During this, the system is supported as per the terms of warranty in the contract with the client. In this period issues are tracked and resolved based on the contact.

Quality Assurance:

In Pyxisnet, a PQE (Project Quality Evaluator) is assigned to each project when it is initiated. It is ensured that the PQE does not have any direct reporting relationship to the Project Manager controlling the project. He ensures quality output to the customer.

The PQE is part of the team that reviews the Project Management Plan and other related plans with respect to the quality assurance perspective. The PQE also prepares a Project Quality Assurance Plan for the project.

Project Management:

At Pyxisnet, we have our own project management manual that provides guidelines for planning project execution and project risk management. The activities that take place from the time a proposal is accepted (or a contract is signed) to the time the software and services are delivered according to the accepted proposal/contract are covered in the manual. The process ensures the team is making satisfactory progress to the project goals.

We ensure that projects are planned in methodical manner, executed, monitored and controlled in systematic manner. Risks are identified, evaluated and mitigated throughout project life cycle. Our automated process tool helps in managing the projects according to CMMI guidelines.

Auditing:

All our procedures incorporate work-product reviews required for verification, configuration management activities for version control and establishing and maintaining baselines. These are validated through regular audits.

Configuration management and version control tools:

We use various tools for our configuration management. Local development is done using Source Safe and CVS. Both the source control tools are maintained in secure server under our domain controller. Authorized users have access only to their related projects repository.