Writes Swift or Kotlin code according to our style guides

Proactive in asking questions, explains what they have tried so far and why that hasn’t worked

Updates layout to existing screens

Builds simple screens or flows

Asks questions and actions feedback from PRs and other engineers

Fixes simple bugs or issues

Uses appropriate algorithms and data structures to solve problems

Uses appropriate design patterns

Responsible for building small to medium sized new features inside the app

Modifies and improves existing parts of the app (and reasons about the improvements)

Adds basic UI tests or snapshots

Proactively learns new things and seeks out people who can help them

Manages the release master process

Contributes to Android or iOS chat

Appropriately uses common functional reactive programming concepts

Designs database models

Appropriately handles errors or failure conditions in their code

Works with designers to handle empty, error, and loading states in multi screen flows

Integrates with new APIs

E.g. Can add an integration with a new backend endpoint and handle return data, Can add an integration with a documented third party API

Uses concurrency appropriately

E.g. Can reason whether to use asynchronous or synchronous operations, understands impact on app performance to use either

Uses tools to diagnose and improve performance issues

Builds non-trivial, coordinated app flows with multiple services and data sources

Builds complex UI layouts in code or via IDE

Contributes to group standards, impactful in improving our processes

Proactively improves empty, error and loading states in screens & flows they encounter, works closely with designers to identify problem areas and suggest improvements

Adds migrations to handle changes between old and new app versions

E.g. Owning migration from major language versions, handling complex changes to third party dependencies, writing migrations from one data schema to another

Writes code that serves as a definitive example for new engineers

Identifies and fixes security vulnerabilities

Sought out for reviewing complex changes or commenting on larger scale proposals

Builds flows that serve as an example of high quality interaction design

Owns and coordinates large scale architectural changes to the entire codebase

- Researches potential solutions and evaluates how they solve the problem.

- Able to articulate why a change in architecture is needed and the impact this will have on the team and business.

- Dissects into discrete tasks and works with other team members to resolve issues.

- Examples include network request lifecycle and authorisation, model layer and persistence, app navigation and coordination (eg deep links), and modularisation

Debugs complex problems across a variety of subject areas

- Seeks out technical knowledge to compliment their own, researches and patches third party libraries where needed. Uses reasoning to debug and find the root cause of issues.

- Articulates problem and proposed solution to both technical and non technical peers.

Writes proposals and architects complex app flows

- Coordinates with backend developers around API specifications and requirements.

- Able to digest into discrete tasks and work with peers to solve problem in an efficient manner to avoid blockers.

Anticipates large or significant platform changes, work with team to define possible solutions. Starts or finishes these projects.

Takes high level requirements and turns them into discrete technical concerns

Instills and maintains a culture of high quality interaction design in their discipline

Coordinates group efforts across horizontal

A technical authority for iOS/Android on multiple teams, working with team leads and other engineers across the company.

Anticipates platform/project needs from other teams, technical debt and common problems

Proactively seeks out solutions for problems not owned by product teams, works with others to scope and identify solutions. Justifies effort to PMs in order to schedule work.

Takes charge of low level deep dives when debugging complex issues.

- Able to handle situations where domain knowledge does not exist in the company and can lead the effort to resolve them.

- For example, resolving issues with our compiler and mapping out code paths for 'hard to reproduce' issues