Safe Release Management #

Release management ensures that new features, updates, and bug fixes are systematically and reliably delivered to users. This document outlines the steps and best practices for managing releases and deployments.

1. Release Planning #

Define the scope: Identify features, enhancements, and bug fixes to include.
Clearly outline the goals and features of the release. Ensure alignment with business objectives set at the begonning of the sprint.
Establish a timeline, allocate resources, and assign responsibilities. Include stages like staging and production. Publish this in release-related slack channel, tag stakeholders.

2. Code Freeze #

Code freeze should be implemented after the final round of feature testing on dev but before the final release candidate build to staging. No new features are added to the since this moment. This helps stabilize the codebase and reduces the risk of last-minute bugs.
The last changes should be merged into the dev well before (depends on changes) the code freeze date. This allows sufficient time for thorough testing.
Announce the code freeze in advance to all stakeholders in development-related slack channel. Ensure everyone understands its purpose and implications.

3. Before Staging Testing #

Run automated tests for end-to-end scenarios. This helps catch regressions early. Review and address test failures promptly. Ensure all tests pass/resolved before merging code into the staging.
Conduct manual testing, especially for critical paths and edge cases that automated tests might miss. Perform regular integration testing.
If needed, engage stakeholders(i.e. Product owner) to perform User Acceptance Testing along with QA team to validate that the release meets business requirements.
Prioritize and address UAT feedback.

4. Release Candidate #

After the code freeze and thorough testing, create a release candidate build.
Deploy the release candidate to a staging environment that mirrors production.
Run automated tests for end-to-end scenarios. Review and address test failures promptly.
Conduct final validation and smoke tests.

5. Deployment Coordination #

Develop and declare in release related channel a detailed deployment plan, including manual steps and production settings set up.
Make sure each engaged team member is online. Announce deplyment start in release related channel.
Each team member who responsible for the release should communicate clearly their progress/issues/blockers faced during the release. They should noitify team when their part of release is done.
Monitor the deployment process closely for any issues. Use monitoring tools to track application performance and stability.
Address any incidents or issues that arise.
Ensure all dependencies and configurations are in place.
Follow the deployment checklist to ensure all steps are completed.
Prepare release notes.

6. Post-Release #

Have a clear rollback strategy in place in case of critical issues post-deployment.
Update documentation and knowledge base with any changes made during the release process.
During 1 week continuously monitor the production environment for any issues or performance degradations.
Address any incidents or issues that arise.
Collect feedback from users and stakeholders. Address any issues or improvements for future releases.
Provide support to users and stakeholders.
Once make sure live is stable - unblock dev code freeze.

7. Hotfix Management #

Quickly identify and prioritize critical bugs that need immediate attention.
Identify and mitigate potential risks. Communicate risks with stakeholders.
Create a hotfix branch from the staging branch. Apply the fix and thoroughly test it.
Deploy the hotfix to production. Merge the changes back into the dev and staging branches.
Once make sure live is stable - unblock dev code freeze.

Code Freeze and Unmerged Features. #

For a 2-week sprint, the duration of the code freeze can vary depending on the complexity of the features and the stability of the codebase, but typically it would last for 1-3 days before the end of the sprint.

But there are factors to consider:

Project Complexity: More complex projects may require a longer freeze.
Testing Needs: Consider the time needed for thorough testing and bug fixes.
Historical Data: Use past sprints as a reference to determine the ideal freeze duration.

Recommended Actions for Unmerged Features (ready after code freeze) #

Determine the importance and urgency of the unmerged features.
Check if other features or parts of the project depend on these changes.
Inform all relevant stakeholders about the unmerged features and the potential impact.
Ensure that developers are aware of the situation and can prioritize accordingly.
Choose an option for handling unmerged features:
- Postpone to Next Sprint: If the features are not critical, plan to merge them in the next sprint.
- Hotfix Post-Release: If the features are critical but can be released after the main release, plan a hotfix deployment.
- Extend Code Freeze: If feasible, extend the code freeze period slightly to accommodate the merging and testing of these features.
Document the challenges and resolutions related to the unmerged features.
Discuss during the sprint retrospective to improve future sprint planning and execution.

Recommended Timeline for a 2-Week Sprint #

Day 1-5: Development and tesing of new implemented features.

Day 5-6: Last merging completed features into the develop branch. Conduct last merged feature testing.

Day 8-9: Code freeze period. No new features are added. Focus on final testing and bug fixing.

Day 10: Final testing and preparation for release.

By implementing these practices, you can effectively manage the code freeze period and ensure that your release process remains smooth and efficient, even if not all features are merged on time.

Project manager responsibilities during the release: #

Develop and maintain a release schedule that includes all phases from development to deployment.
Coordinate with developers, QA, and other teams to ensure alignment and smooth transitions between stages.
Identify potential risks and issues that could impact the release schedule or quality. Implement mitigation strategies to address identified risks.
Keep all stakeholders informed about the release plans, progress, and any issues that arise.
Make sure the release management process (described above) are followed efficiently.
Implement and enforce code freeze periods to stabilize the codebase before release.
Ensure that comprehensive testing is conducted, including unit, integration, system, and user acceptance testing.
Verify that the software meets quality standards and that all identified issues are resolved before release.
Oversee the deployment process to ensure it is executed smoothly and efficiently, ensure that deadlines are met.
Monitor the application post-deployment to quickly identify and resolve any issues that arise.
Provide regular status reports to stakeholders, highlighting progress, risks, and any required actions.
Regularly collect feedback, review, and refine the release process based on feedback and lessons learned.

A well-defined release and deployment process is essential for delivering high-quality software efficiently and reliably. By following these steps and best practices, we can ensure that our releases are well-planned, thoroughly tested, and smoothly deployed, providing value to our users and stakeholders.