Reading/Roles and responsibilities

The mobile web team is comprised of the following roles, which are defined by their associated responsibilities.

Product owner
The product owner, in a nutshell, is ultimately responsible for the product or service to be delivered. The product owner is responsible for:
 * Providing vision for the product or service being developed
 * Being the single point of escalation for contending priorities among stakeholders
 * Managing the product road map
 * Making final decisions about trade-offs when desired functionality, or scope, exceeds the capacity of the team
 * Defining the target constituent for iterations, releases, and the overall product
 * Making final decision about whether or not work done on stories is complete ('acceptance'). NOTE- bugs and technical/non-user-facing stories are treated differently from user-facing work:
 * if a bug is resolved in Bugzilla, it is automatically considered "signed off"
 * for tech tasks, whoever merges the task has indicated that they sign off on it
 * Doing the work of determining what features the team should work on in order to achieve our user, community, and Foundation goals. This is done in collaboration with the team
 * Making sure that our products have a coherent, compelling user experience

Because the product owner has the final say over prioritization, there should be only one person acting as product owner.

Scrummaster
The scrummaster is primarily responsible for maintaining the team's process and ensuring the team delivers what is expected from the product owner. Responsibilities include:
 * Evolving team/agile capacity
 * Removing blockers
 * Leading/coordinating/facilitating whole team in story delivery
 * Facilitating meetings
 * Optimizing process
 * Coordinating project work streams
 * Helping to manage project/iteration scope
 * Managing external dependencies
 * Escalating risks/issues
 * Reporting on progress

Tech lead
The tech lead guides and represents the engineering team. Responsibilities include:
 * Assisting in planning activities and representing the engineering team at planning meetings when the rest of the team is not present
 * Owning the maintenance of the quality and architectural coherence of the code developed by the project
 * Escalating significant architectural/technical issues for prompt resolution
 * Coordinating regular refactoring/code hygiene to prevent accumulation of technical debt
 * Communicating, educating, and enforcing technical best practices and standards
 * Coordinating on-boarding of new team members
 * Work with product owner and scrummaster to ensure Google Hangouts and meeting rooms are scheduled
 * Scrum of scrums on Tuesdays sync up with other team members
 * Reporting where team impacts other teams
 * Reporting to team when we are likely to be impacted by other teams changes.
 * Keep the scrum of scrums board up to date.
 * Phabricator
 * Understand and prioritise new bugs in preparation for daily scrum bug triage.
 * Respond to bugs where more information is needed or to acknowledge them and provide guidance on how and if they should be resolved.
 * Be responsible for ensuring that appropriate bugs get WONTFIXED when there are technical problems
 * Ensure that all bugs are actionable or close to actionable.
 * Ensure along with the product owner that features move or are killed from beta and alpha modes.
 * Responsible for ensuring that the team has a presence in important conversations on mobile-l or wikitech-l mailing lists.
 * Proactively facilitate impromptu discussions with remote peers
 * Supporting recruiting & hiring in coordination with Engineering Director

Quality Assurance Analyst (QA)
QA oversees the quality of the product. Responsibilities include:
 * Producing test cases/scenarios
 * Manual testing when not automated/automatable
 * Maintaining regression test suite
 * Integration testing
 * Exploratory testing
 * Assisting in acceptance criteria definition
 * Training and otherwise working with engineers in best-practices for assuring code and product quality

Engineer
Engineers build the product and coordinate the construction of supporting infrastructure. Responsibilities include:
 * Turning user stories/requirements into working software
 * Conducting the technical analysis of requirements
 * Assisting in the evolution of user experience designs
 * Coordinating the implementation of supporting architecture/infrastructure
 * Assisting with testing
 * Estimating user stories
 * Working with QA to automate testing scenarios
 * Presenting work to QA and BA for final testing
 * Escalating risks and issues that impact scope and timeline
 * Writing code in line with project standards
 * Standing behind architectural decisions, patterns and best practices that the team has agreed to
 * Signing off on bugs and technical/non-user-facing stories:
 * if a bug is resolved in Bugzilla, it is automatically considered "signed off"
 * for tech tasks, whoever merges the task has indicated that it is signed off on and the tsp can be moved to 'Done'

User Experience (UX) Designer
The UX Designer defines how users will interact with the product. Responsibilities include:
 * Gathering data to assess needs/requirements of users
 * Proposing designs to define how users will interact with the functionality of the product (including designs of UX in general, and the product's interface in particular)
 * Providing design expertise and guidance to engineers and QA during code writing and testing
 * Ensuring that the product is not only useful, but usable as well
 * Assisting in narrative and user story development, particularly in the delivery of development-ready design assets and/or prototypes
 * Leading usability testing and logging associated findings

Engineering director
The engineering director is responsible for the staffing of the engineering team and the annual department goals. Responsibilties include:
 * Defining annual goals of the department
 * Running department quarterly reviews with executive team
 * Resourcing team as necessary
 * Personnel discipline
 * Providing staff mentorship for personal and professional growth
 * Coordinating across department engineering teams
 * Connecting external partners with internal team as necessary
 * Budgeting