act like a Project manager and Scrum master who manage a scrum team that works on bitbucket and jira on a software development project, write a description to describe the role in the team and responsibilities of each role following guild bellow
- The requirement has to be prepared and ready before the sprint planning session
- the Jira board has a backlog, ready for dev, in progress, code review, and ready for test statues
- each ticket has a corresponding git branch
- git commit has to be related to the ticket
- ticket description has to be in a format that the developer or designer knows what todo
- developer or designer has to comment on the ticket the solution and impact of the change to the software
- product owner has to note the plan for the next sprint a week before the sprint start, pm has the responsibility to help the product owner archive that
- a technical leader needs to review the code and create the release note every build
- tester needs to define the test case, execute the test, and report before release
- the product has a dev, stag,e, and prod environment reflected with develop, staging and main git branch
- designer works with product owner, take note to the jira ticket and design UI UX for the product

list all the roles and responsibilities in table format
user
Sure, here's a table format that summarizes the roles and responsibilities in a Scrum team working on a software development project using Jira and Bitbucket:

| Role | Responsibilities                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|-------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Project Manager (PM) | - Facilitate sprint planning                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 - Coordinate with Product Owner to prepare andready requirements before sprint planning                                   - Ensure Jira board has a backlog, ready for dev, in progress, code review, and ready for test statues                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - Help Product Owner define plan for next sprint a week before sprint start                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Scrum Master (SM) | - Facilitate daily stand-up meetings                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Developer (DEV) | - Develop features/bugs based on Jira tickets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             - Create a Git branch for each Jira ticket                                                                                                                                                                                                                                                                                                                                                                     - Commit changes to Git with a ticket ID in the commit message                                                                                                                                                                                                                                                             |
| Designer (DES) | - Work with Product Owner to take notes from Jira tickets and design UI/UX for the product                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - Update the designer's document by design                                                                                                                                                                                                                                                                                                                                                                                       |
| Jira Administrator (JIRA Admin) | - Setting up boards, issuetypes, components, workflow, custom fields, etc.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       - Maintaining Jira using best practices                                                                                                                                                                                                                                                                                                                                                                                             - Providing technical support to Jira users                                                                                                                                                                                                                                                                                                                                                                             - Keeping Jira config up-to-date with new team's requirements and policies                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Bitbucket Administrator (BT Admin) | - Installing, configuring & maintaining Bitbucket server                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       - Providing technical support to Bitbucket software developers                                                                                                                                                                                                                                                                                                                                                                                                  - Coordinating with Jira admin- create a branch of each JIRA ticket created for every issue                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Technical Leader (TL) | - Reports unit or component tests                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - Following team best practices aka coding standards |
| Tester (QA) | - Create a test case, based on Jira, for developed features, re-test                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - Reviewing test plans, reports, and statuses with the product owners                                                                                                                                                                                                                                                                                                                                                                                          - Create and run Test Cases, smoke, answer is there, more, user acceptance test, bug, and non-functional test cases and document results                                                                                                    |

Note: The list above is not exhaustive. Real-life requirements and responsibilities may vary.
assistant
act like a Project manager and Scrum master who manage a scrum team that works on bitbucket and jira on a software development project, write a description to describe the role in the team and responsibilities of each role following guild bellow
- The requirement has to be prepared and ready before the sprint planning session
- the Jira board has a backlog, ready for dev, in progress, code review, and ready for test statues
- each ticket has a corresponding git branch
- git commit has to be related to the ticket
- ticket description has to be in a format that the developer or designer knows what todo
- developer or designer has to comment on the ticket the solution and impact of the change to the software
- product owner has to note the plan for the next sprint a week before the sprint start, pm has the responsibility to help the product owner archive that
- a technical leader needs to review the code and create the release note every build
- tester needs to define the test case, execute the test, and report before release
- the product has a dev, stag,e, and prod environment reflected with develop, staging and main git branch
- designer works with product owner, take note to the jira ticket and design UI UX for the product

list all the roles and responsibilities in table format
user
| Role               | Responsibilities                                                                                                                                                                                                                     |
|--------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Project Manager    | - Coordinate with the Product Owner to prepare requirements before the sprint planning session                                                                                                                                       |
|                    | - Assist the Product Owner in planning for the next sprint a week before it starts                                                                                                                                                    |
|                    | - Facilitate communication and collaboration within the team                                                                                                                                                                         |
|                    | - Ensure project progress aligns with the project's objectives and timelines                                                                                                                                                         |
|                    | - Manage risks and issues and take corrective actions when necessary                                                                                                                                                                  |
| Scrum Master       | - Facilitate sprint planning, daily stand-ups, sprint review, and retrospective meetings                                                                                                                                             |
|                    | - Ensure the team follows the Scrum framework and guidelines                                                                                                                                                                          |
|                    | - Remove any obstacles or blockers that the team may encounter                                                                                                                                                                      |
|                    | - Promote continuous improvement within the team                                                                                                                                                                                      |
| Product Owner      | - Define and prioritize user stories in the Jira backlog                                                                                                                                                                              |
|                    | - Ensure that tickets in the Jira backlog are ready for development with clear and concise descriptions                                                                                                                                  |
|                    | - Collaborate with the designer to create UI/UX designs based on the user stories                                                                                                                                                   |
|                    | - Coordinate with the Project Manager to plan for the next sprint                                                                                                                                                                    |
|                    | - Review and accept/reject completed work based on the acceptance criteria                                                                                                                                                          |
| Developer          | - Work on tickets from the Jira board and move them through different statuses (ready for dev, in progress, code review, ready for test)                                                                                            |
|                    | - Create a corresponding git branch for each ticket                                                                                                                                                                                 |
|                    | - Make sure git commits are related to the ticket                                                                                                                                                                                   |
|                    | - Comment on the ticket with the solution and impact of the changes to the software                                                                                                                                                 |
| Technical Leader   | - Review the code submitted by developers                                                                                                                                                                                            |
|                    | - Create release notes for every build                                                                                                                                                                                               |
|                    | - Provide technical guidance and support to the developers                                                                                                                                                                          |
| Tester             | - Define test cases based on the user stories and acceptance criteria                                                                                                                                                               |
|                    | - Execute tests on the developed features                                                                                                                                                                                            |
|                    | - Report test results and any identified issues before release                                                                                                                                                                       |
| Designer           | - Collaborate with the Product Owner to understand the requirements and create UI/UX designs                                                                                                                                          |
|                    | - Update the Jira tickets with notes and design assets                                                                                                                                                                                 |
|                    | - Provide clarification and support to developers when implementing the designs                                                                                                                                                        |
assistant