assurance checklist by software vendor during deploying changes
Pre-Deployment Planning
Code Review and Quality Assurance
- Assign reviewers knowledgeable about the codebase.
- Set a deadline for review completion.
- Discuss findings in a meeting or comment thread.
- Incorporate feedback into the code.
- Document any significant changes made.
- Review coding standards documentation.
- Use automated tools to check code style.
- Conduct a manual review for complex cases.
- Provide suggestions for improvements.
- Ensure consistency across the codebase.
- Select appropriate static analysis tools.
- Integrate the tools into the build process.
- Review the analysis report for findings.
- Prioritize issues based on severity.
- Fix identified issues before deployment.
- Create or update unit tests as needed.
- Run all unit tests in the testing environment.
- Verify that tests cover all edge cases.
- Document any tests that fail.
- Refactor code if necessary to pass tests.
- Review test case results after execution.
- Investigate any failed test cases thoroughly.
- Address defects before moving to production.
- Conduct regression testing to confirm stability.
- Compile a report of test results for stakeholders.
- List all current dependencies.
- Check for the latest versions in official repositories.
- Update any outdated libraries.
- Document changes and reasons for updates.
- Ensure compatibility with the existing code.
- Define test cases based on requirements.
- Execute tests on new features.
- Log results and any issues found.
- Verify that features meet functional specifications.
- Re-test after fixes are implemented.
- Identify modules that interact with each other.
- Develop integration test cases.
- Execute tests to ensure modules work together.
- Document any integration issues.
- Confirm that data flows correctly between services.
- Locate relevant documentation affected by changes.
- Update technical and user documentation.
- Ensure clarity and completeness of information.
- Review changes for accuracy.
- Distribute updated documentation to stakeholders.
- Review code for common vulnerabilities.
- Implement security measures in code.
- Run automated security scans.
- Address any identified security issues.
- Document security practices and findings.
- Define performance benchmarks.
- Create test scenarios based on usage patterns.
- Run load and stress tests.
- Analyze performance metrics.
- Optimize code where necessary based on results.
- Review error handling code paths.
- Ensure logging captures relevant information.
- Test error conditions to verify handling.
- Confirm logs are accessible and useful.
- Document error handling strategies.
- Review commit messages for clarity and purpose.
- Ensure branches follow naming conventions.
- Check for proper merging practices.
- Confirm that the main branch is stable.
- Document version control guidelines.
- Create migration scripts for database changes.
- Test scripts in a staging environment.
- Verify data integrity post-migration.
- Document database schema changes.
- Rollback scripts should be prepared and tested.
- Define exploratory testing sessions.
- Encourage testers to think creatively.
- Document findings and unexpected behaviors.
- Report issues to development for resolution.
- Review exploratory testing outcomes.
- Schedule review sessions with stakeholders.
- Present new features and changes.
- Collect feedback and suggestions.
- Document stakeholder responses.
- Iterate on changes based on feedback.
- Identify relevant accessibility standards.
- Review changes for compliance.
- Test features with accessibility tools.
- Document accessibility findings.
- Make necessary adjustments for compliance.
Use in Manifestly