Study after study has shown that good unit test suites lead to fewer bugs as well as cleaner (refactored) software. The opposite also holds true - lack of comprehensive tests leads to software that is defect-ridden and harder to maintain.  Anuj provides a comprehensive code review of your entire code base which includes:

1. Code Coverage Statistics - to determine what fraction of  your code is missing good test coverage (and hence may be open to defects).
2. Refactoring of larger Components, Classes and Methods - Often times, unintentionally, a class or a component grows to provide more functionality than originally intended. The same may be true of individual methods within classes. Anuj meticulously goes through each class and using proven OO techniques such as composition and inheritance, breaks up larger classes into manageable ones.
3. Revalidation of business process - One of the side-effects of the CoRe^TM service is that re-factoring, by its very nature, involves re-visiting key business process decisions. This leads to a thorough re-validation of core business workflows. Often times, Anuj's CoRe^TM service, has caught major loopholes and missing pieces of functionality - as a pure side-effect of his refactoring efforts.
4. Standardized components for logging, object disposal, exception handling etc, - Another thing that tends to happen on larger projects is a mish-mash of logging methods, memory cleanup and exception handling code. Anuj painstakingly re-works code to ensure that objects get disposed correctly to prevent memory leaks - he inspects all exceptions to ensure that the appropriate ones get handled. In addition, he provides a standardized logging component for the entire application.
5. Documentation - As per one research, less than half of all software applications are well documented. Code documentation usually stays on the back-burner - unless each developer makes a conscientious effort to provide thorough documentation. As part of his re-factoring effort, Anuj provides complete code documentation for the classes and methods that are lacking in this regard.

1. Phase 1 (Code Examination) : The initial phase (examining the code) - takes between 1 to 2 weeks. At the end of this phase, Anuj will provide a list of areas that would benefit from code modifications (including re-factoring, additional unit tests, memory cleanup etc.). He will also provide an estimate of the time required for the second phase. Anuj also provides a comprehensive document at the end of phase 1 - should you choose to use someone else to implement phase 2.
2. Phase 2 (Code Modifications) :  Although it is dependent on the size of the code-base, the second phase takes anywhere from 6 weeks to 12 weeks depending on the volume of code involved.