AI Coding Assistants 1
▼
Uses ChatGPT/Claude for Android development assistance: generating Kotlin code for simple tasks (RecyclerView adapter, Room DAO, Retrofit interface), explaining Android lifecycle and Compose concepts. Formulates queries with context — API version, libraries used, describes expected behavior, verifies generated code before use.
Effectively uses AI assistants for Android development: unit test generation with MockK, Compose refactoring, Room migration creation, Gradle script writing. Provides architecture context (MVVM, Hilt), specifies team coding conventions, iteratively refines results. Uses AI for debugging — crash log analysis, Compose recompositions, ProGuard mapping.
Integrates AI assistants into the Android development workflow: auto-generating boilerplate (feature module scaffolding, DI setup, Navigation graph), creating architectural documents and ADRs. Uses AI for code review preparation, performance trace analysis, Espresso test generation from user stories. Critically evaluates AI recommendations on Android APIs — checks deprecated APIs and compatibility.
Defines AI assistant usage standards for the Android team: recommended prompts for typical tasks (feature template, test generation, code review), security guidelines (do not share secrets, API keys). Implements AI into team processes — auto-generating PR descriptions, changelogs, module documentation, trains the team on effective prompt patterns for mobile development.
Algorithms & Data Structures 2
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Kotlin. Follows recommendations from senior developers when solving problems.
Independently applies algorithmic thinking in Android development: selects efficient list sorting/filtering for UI, understands diff algorithm impact on RecyclerView performance, applies background task scheduling algorithms. Evaluates computational complexity of data processing operations.
Applies algorithmic thinking to Android performance optimization: efficient sorting/filtering for large RecyclerView datasets, diff algorithms for ListAdapter updates, scheduling algorithms for background work coordination. Designs efficient algorithms for offline data synchronization and conflict resolution.
Designs algorithmically optimal solutions for Android applications: efficient search, sorting large lists in RecyclerView, optimizing graph traversal for navigation. Conducts code reviews focusing on O-notation, trains the team on choosing data structures for specific mobile scenarios — caching, pagination, offline-first approaches.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using Kotlin. Follows recommendations from senior developers when solving problems.
Independently selects appropriate data structures for Android apps: LiveData/StateFlow for reactive UI state, Room entity relationships for local storage, efficient adapters for RecyclerView. Understands trade-offs between mutable and immutable data containers for UI rendering.
Selects optimal data structures for Android applications: sparse arrays, Room entity relationships, efficient RecyclerView data sources for large lists. Optimizes in-memory caching with LRU strategies for image and data stores. Designs offline-first data models with proper sync conflict resolution structures.
Defines data structure usage standards for Android projects: SparseArray instead of HashMap for int keys, ArrayDeque for event queues, TreeMap for sorted caches. Reviews team architectural decisions, trains on choosing optimal Kotlin collections for specific scenarios — StateFlow, SharedFlow, Channel.
Android Development 4
▼
Uses Android Architecture Components at a basic level. Creates simple screens from design. Understands the application lifecycle.
Independently implements complex screens with Android Architecture Components. Optimizes performance and memory consumption. Works with asynchronous patterns.
Designs mobile application architecture with Android Architecture Components. Optimizes performance for low-end devices. Implements CI/CD for mobile development. Mentors the team.
Defines Android application architectural standards: choosing between MVVM and MVI for different screens, feature module decomposition rules, contracts between layers (domain, data, presentation). Implements multi-module architecture with proper dependency inversion, configures Hilt modules for DI, conducts architectural reviews for all new features.
Uses Kotlin and Jetpack Compose at a basic level. Creates simple screens from design. Understands the application lifecycle.
Independently implements complex screens with Kotlin and Jetpack Compose. Optimizes performance and memory consumption. Works with asynchronous patterns.
Designs mobile application architecture with Kotlin and Jetpack Compose. Optimizes performance for low-end devices. Implements CI/CD for mobile development. Mentors the team.
Defines Jetpack Compose standards for the Android team: composable function architecture, state hoisting and side-effect rules, recomposition strategies for optimal performance. Implements a Compose-based design system (Material 3 customization), configures preview configurations, trains the team on correct patterns — remember, derivedStateOf, LaunchedEffect.
Uses Kotlin Coroutines and Flow at a basic level. Creates simple screens from design. Understands the application lifecycle.
Independently implements complex screens with Kotlin Coroutines and Flow. Optimizes performance and memory consumption. Works with asynchronous patterns.
Designs mobile application architecture with Kotlin Coroutines and Flow. Optimizes performance for low-end devices. Implements CI/CD for mobile development. Mentors the team.
Establishes coroutine standards for the Android team: structured concurrency rules, choosing between StateFlow and SharedFlow for UI state, error handling patterns via CoroutineExceptionHandler. Implements coroutine testing via Turbine and TestDispatcher, defines cancellation and timeout rules, trains the team on advanced Flow operators.
Uses Navigation and Deep Links at a basic level. Creates simple screens from design. Understands the application lifecycle.
Independently implements complex screens with Navigation and Deep Links. Optimizes performance and memory consumption. Works with asynchronous patterns.
Designs mobile application architecture with Navigation and Deep Links. Optimizes performance for low-end devices. Implements CI/CD for mobile development. Mentors the team.
Defines Android application navigation architecture: Navigation Component standards with Safe Args, deep linking strategy, back-stack management rules for complex flows. Implements type-safe navigation in Compose, configures multi-module navigation via navigation graphs, trains the team on patterns — nested graphs, conditional navigation, results between screens.
Application Security 2
▼
Knows the main mobile application vulnerabilities from OWASP Mobile Top 10: insecure data storage, weak authentication, unprotected data transmission. Understands the importance of HTTPS, does not store passwords in SharedPreferences in plain text, uses EncryptedSharedPreferences for sensitive data, checks permissions before accessing camera and contacts.
Applies OWASP MASVS recommendations in Android development: reverse engineering protection via ProGuard, root detection via SafetyNet, data leakage prevention through clipboard and screenshots. Implements certificate pinning, configures Network Security Config for cleartext traffic restriction, performs basic security audits using MobSF and JADX.
Ensures OWASP MASVS-L2 compliance for Android applications: full audit against MASVS checklist, anti-tampering protection implementation, runtime application self-protection (RASP). Configures obfuscation via R8 with custom rules, implements jailbreak/root detection with graceful degradation, conducts threat modeling for mobile attack vectors, integrates SAST/DAST into CI pipeline.
Follows basic secure coding practices in Android: does not log sensitive data via Log.d, uses parameterized Room queries instead of string concatenation, does not store secrets in code. Understands the difference between MODE_PRIVATE and MODE_WORLD_READABLE for files, uses Content Provider with correct permissions, validates user input before sending to the server.
Applies secure coding practices in Android projects: SQL injection protection via parameterized Room queries, intent injection prevention through explicit intents, deep link parameter validation. Uses Android Keystore for cryptographic keys, implements secure random via SecureRandom, configures exported=false for internal components, conducts security vulnerability reviews.
Designs Android application security patterns: secure data storage architecture (Keystore + EncryptedFile), IPC protection through signature-level permissions, anti-debugging and anti-tampering protection. Implements code obfuscation strategy via R8 with custom dictionary, implements SSL pinning with backup pins, configures ProGuard rules for security-critical classes, conducts security code reviews.
Defines secure coding standards for the Android team: security coding guidelines, mandatory security review for auth/payment/data modules, pre-release checklists. Implements SAST tools (Detekt security rules, MobSF) in CI, conducts security training for developers, coordinates vulnerability fixes with severity-based prioritization.
Authentication & Authorization 1
▼
Understands JWT/OAuth2 basics for Android: token storage in EncryptedSharedPreferences, OAuth2 authorization code flow with PKCE, and refresh token handling. Implements login/logout flows using AppAuth or custom OAuth2 clients. Follows team guidelines on secure token management.
Implements OAuth 2.0 with PKCE in Android via AppAuth or custom implementation: code_verifier/code_challenge generation, redirect URI handling via deep link, code-to-token exchange. Implements refresh token rotation with concurrent request handling, stores tokens in EncryptedSharedPreferences, configures OkHttp Authenticator for transparent refresh, handles token revocation.
Designs Android application auth architecture: multi-provider authentication (Google Sign-In, Facebook, Apple via Credential Manager), biometric authentication via BiometricPrompt with crypto object. Implements session management with secure token storage in Android Keystore, configures token binding, designs graceful auth degradation and offline authentication via cached credentials.
Defines authentication standards for the Android platform: unified auth module for all applications, SSO strategy between apps (via Custom Tabs or shared Keystore), key rotation processes. Implements Passkeys/FIDO2 via Credential Manager API, coordinates auth standards with the backend team, trains the team on security aspects of mobile authentication.
Clean Code & Refactoring 1
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Kotlin. Follows recommendations from senior developers when solving problems.
Independently applies code quality practices in Android development. Writes clean Kotlin code following Material Design and Compose guidelines. Understands trade-offs between reactive and imperative UI patterns. Reviews colleagues' code for lifecycle management, memory leaks, and navigation consistency.
Designs code quality standards for Android projects: Kotlin coding conventions, Compose best practices, modularization strategies for large apps. Configures Detekt/ktlint with custom rules. Refactors legacy Activity-based code to modern architecture patterns. Establishes PR review criteria for UI consistency.
Builds a code quality system for the Android team: detekt and ktlint configuration with custom rules, SonarQube integration for Kotlin, mandatory code review checklists. Implements Android-specific lint rules, KDoc documentation standards, test coverage metrics. Trains the team on clean Kotlin code principles and architectural conventions.
Concurrency & Parallelism 1
▼
Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using Kotlin. Follows recommendations from senior developers when solving problems.
Independently applies multithreading for Android: coroutines with structured concurrency, Flow for reactive data streams, WorkManager for background task scheduling, understanding of ANR prevention through proper thread management. Explains concurrency trade-offs for Android lifecycle in code review.
Has deep expertise in Android multithreading: designs coroutine-based architectures with proper scope management, implements concurrent data processing with Flow operators, optimizes thread pool configurations for Android runtime. Mentors team on structured concurrency patterns for complex Android applications.
Manages multithreading in Android team applications: Main thread rules, context switching standards via Dispatchers, thread-safe patterns for SharedPreferences and database work. Implements diagnostic tools — StrictMode, ANR analysis, thread profiling in Android Studio for detecting locks and deadlocks.
E2E Testing 1
▼
Runs existing Android E2E tests via Espresso: understands basic matchers (withId, withText), actions (click, typeText), and assertions (matches, isDisplayed). Can add a simple test for a new screen following a template, runs tests on an emulator via Android Studio, reads reports and identifies test failure causes with mentor help.
Writes Android E2E tests via Espresso and UI Automator: testing complete user flows (registration, purchase, settings), working with RecyclerView via RecyclerViewActions, handling animations through IdlingResource. Uses Espresso-Intents for intent verification, tests deep links, configures test orchestrator for test isolation, works with Compose Testing for Compose screens.
Designs Android E2E test infrastructure: Page Object pattern for Espresso tests, Robot Pattern for readable tests, test data strategy (seeding, cleanup). Configures parallel execution on Firebase Test Lab with sharding, implements screenshot testing via Paparazzi, optimizes test stability — retry strategies, custom IdlingResources for async operations.
Defines E2E strategy for the Android team: critical user journeys for mandatory E2E coverage, execution time budget (<30 min), flaky test processes (quarantine, fix SLA). Implements visual regression testing for UI consistency, configures nightly E2E runs on Firebase Test Lab across a device matrix, trains the team on writing stable and maintainable E2E tests.
General Mobile Practices 1
▼
Understands basic ASO concepts for Android apps: keyword research fundamentals, app title and description optimization, screenshot and icon guidelines for Google Play Store. Follows team conventions for store listing metadata preparation.
Independently implements ASO strategies for Android apps: conducts keyword analysis using App Annie/Sensor Tower, optimizes store listings for conversion, A/B tests screenshots and descriptions. Understands Google Play ranking factors and review management best practices.
Designs comprehensive ASO strategy for Android products: builds keyword tracking dashboards, implements automated store listing experiments, analyzes competitor ASO tactics. Optimizes conversion funnels from impression to install and mentors team on ASO practices.
Defines ASO standards for mobile product portfolio: establishes store listing optimization workflows, coordinates ASO with marketing and product teams, implements cross-app keyword strategies. Conducts ASO audits and defines the technical roadmap for store presence.
Integration Testing 1
▼
Understands the concept of Android integration testing: verifying component interactions (ViewModel + Repository, Repository + Room). Runs existing integration tests, understands the difference between unit and integration tests, uses in-memory Room database for testing DAO queries under mentor guidance, reads test result reports.
Writes Android integration tests: Room DAO testing with in-memory database, Retrofit client verification via MockWebServer, ViewModel + UseCase + FakeRepository integration. Uses Hilt Testing for dependency substitution in tests, verifies Navigation flows via TestNavHostController, configures test fixtures for complex multi-data-source scenarios.
Designs Android application integration testing strategy: end-to-end tests of the data layer (API→Repository→Room), Room migration testing via MigrationTestHelper, contract testing with backend via Pact. Configures test environment with realistic data, optimizes integration test startup time, implements snapshot testing for complex state machines.
Defines integration testing strategy for the Android team: testing pyramid (unit/integration/e2e ratio), feature module testing standards, smoke testing processes before release. Implements automatic integration test runs on real devices via Firebase Test Lab, configures flaky test detection and quarantine, trains the team on effective integration patterns.
OOP & Design Patterns 1
▼
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Kotlin. Follows recommendations from senior developers when solving problems.
Independently applies OOP/SOLID in Android development: proper ViewModel/Repository separation, interface-based dependency injection with Hilt/Dagger, single responsibility in Compose UI components. Understands trade-offs between inheritance and composition for Android UI patterns.
Applies OOP/SOLID in Android architecture: clean separation with MVVM/MVI patterns, interface segregation for repository contracts, dependency injection with Hilt/Dagger. Designs modular Android apps with proper abstraction layers for testability, platform-specific implementations, and feature module independence.
Ensures SOLID principle adherence in the Android codebase: single responsibility for ViewModel and UseCase, open-closed via Repository abstractions, interface segregation for inter-module contracts. Conducts architectural reviews focusing on OOP principles, establishes inheritance and composition standards for Kotlin classes in the team.
REST API 1
▼
Uses REST API in Android via Retrofit: creating interfaces with @GET, @POST, @PUT, @DELETE annotations, mapping JSON responses to Kotlin data classes via Moshi or Kotlinx Serialization. Understands HTTP response codes, sends parameters via @Query and @Path, handles basic network errors using try-catch in coroutines.
Designs Android application REST client: OkHttp interceptor configuration for authorization (Bearer token), refresh token logic implementation, typed error handling via sealed Result classes. Implements response caching through OkHttp Cache and Room, configures date and enum serialization, works with multipart upload for files and images.
Architecturally designs the Android application's network layer: Repository abstraction over Retrofit with unified error handling, offline-first strategies via NetworkBoundResource pattern, client-side API versioning. Optimizes network requests — batching, deduplication of concurrent requests, conditional requests via ETag/Last-Modified, configures connection pooling in OkHttp.
Defines API integration standards for the Android team: unified networking module with typed errors, API version migration strategy, interaction contracts with the backend team. Implements API mocking via MockWebServer for backend-independent development, configures contract testing, trains the team on REST patterns in the context of mobile constraints.
Specialized Testing 1
▼
Understands the fundamentals of mobile testing on Android. Writes basic Espresso and UI Automator tests. Runs instrumentation tests on emulators and physical devices. Applies standard practices for validating UI components and navigation flows in daily work.
Tests Android-specific scenarios: behavior during configuration changes (rotation, locale change), operation under limited memory (onTrimMemory), lifecycle correctness (onSaveInstanceState/onRestoreInstanceState). Tests across different API levels on emulators, tests permissions flow, deep links, push notifications, camera and geolocation in test environments.
Designs mobile-specific testing strategy for Android: testing on real devices via Firebase Test Lab (device matrix), monkey testing with random seed arguments, performance testing via Macrobenchmark. Configures accessibility testing via Accessibility Scanner, verifies backward compatibility across Android API 24-34, implements network condition testing (slow, offline).
Defines mobile testing strategy for the Android team: device matrix for mandatory testing (top 20 devices by analytics), regression testing processes before release, accessibility testing standards. Implements automated compatibility testing, configures crash-free rate monitoring by device and API level, coordinates test case prioritization with the QA team.
State Management 1
▼
Performs simple HTTP requests in Android via Retrofit: GET requests to REST APIs, JSON deserialization via Gson/Moshi into Kotlin data classes. Understands basic concepts — URLs, HTTP methods, response codes. Uses ready-made Repository classes for data loading, displays results in UI via LiveData or StateFlow under mentor guidance.
Implements data fetching with Retrofit and OkHttp, handles pagination and caching strategies. Manages network state with Flow/LiveData. Writes unit tests for repository layer.
Designs the Android application's data-fetching layer: OkHttp interceptor configuration for authorization and logging, response caching strategies, pagination handling via Paging 3. Implements offline-first approach with Room as single source of truth, configures retry policies and exponential backoff, optimizes network requests through batching and deduplication.
Defines networking layer architecture for Android projects: Repository pattern standards, data synchronization strategies (periodic, push-based, conflict resolution). Implements network error monitoring via Firebase Crashlytics, configures network inspection in CI, trains the team on effective data loading patterns considering mobile constraints.