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.
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.
Defines the Android platform's algorithmic strategy: complexity standards for critical paths (app launch, list rendering, data synchronization). Develops internal libraries with optimal algorithms for common mobile tasks. Mentors leads on architectural decisions considering computational complexity on resource-constrained mobile devices.
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.
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.
Shapes the platform data handling strategy in Android: Room schema standards, efficient structures for offline storage, serialization protocols (Protobuf vs JSON). Designs reusable data-layer modules for multi-module applications, defines caching and synchronization policies at the architecture level.
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.
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.
Shapes the Android platform architectural strategy for the organization: reference architectures for different application types, codebase scaling standards up to 50+ modules, inter-team interaction protocols via API modules. Designs platform SDKs and shared libraries, defines technical debt strategy and architecture evolution.
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.
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.
Shapes the Android platform's UI framework strategy: migration from View system to Compose, shared UI component architecture across applications, accessibility standards. Designs cross-platform solutions via Compose Multiplatform, defines rendering performance metrics, creates reference implementations for complex UI patterns.
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.
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.
Defines the Android platform's reactive programming strategy: architectural patterns for complex data pipelines (combine, zip, flatMapMerge), concurrency standards for multi-module applications, background task coordination protocols. Designs solutions for edge-case scenarios — process death recovery, inter-process coroutines, custom dispatchers.
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.
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.
Shapes the platform navigation standard for Android: navigation architecture in multi-module applications with 50+ screens, deep linking strategies for marketing campaigns, A/B testing protocols for navigation flows. Designs solutions for complex scenarios — multi-stack navigation, auth flows, onboarding tunnels, state recovery after process death.
API Protocols 1
▼
Understands the concept of WebSocket connections in Android and how they differ from HTTP requests: persistent bidirectional connection for real-time data. Uses ready-made WebSocket clients (OkHttp WebSocket) to connect to servers, reads and displays incoming messages in UI via LiveData, handles basic events — onOpen, onMessage, onClosed.
Implements WebSocket client in Android via OkHttp: connection lifecycle management tied to Activity/Fragment lifecycle, automatic reconnect with exponential backoff, message serialization/deserialization via Moshi. Handles connection states (connecting, connected, disconnecting), implements heartbeat/ping-pong, buffers messages during connection loss.
Defines real-time communication standards for the Android team: messaging layer architecture, conflict handling protocols for offline-to-online transitions, graceful degradation strategies for unstable networks. Implements WebSocket metrics monitoring (latency, reconnects, message loss), configures load testing for real-time features.
Shapes the platform real-time communications strategy for Android: technology selection (WebSocket, SSE, gRPC streaming, FCM), scalable messaging solution architecture, protocol standards for different use cases (chat, notifications, live updates). Designs fallback strategies and multi-transport architecture for reliable data delivery to mobile devices.
Application Security 1
▼
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.
Architecture Patterns 1
▼
Understands the fundamentals of Clean Architecture. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Implements Clean Architecture in Android applications: domain module with UseCase and Repository interfaces without Android dependencies, data module with Room/Retrofit implementations, presentation module with ViewModel and Compose. Correctly maps models between layers (Entity, Domain, DTO), implements DI via Hilt for layer binding, follows the dependency inversion principle.
Defines Clean Architecture standards for the Android team: module templates (feature-api/feature-impl/feature-test), dependency rules between modules, architectural review processes. Configures Gradle convention plugins to enforce architectural rules, implements ArchUnit for automatic dependency verification, trains the team on Clean Architecture principles and trade-offs.
Shapes the Android organization's architectural culture: evolution of Clean Architecture standards, adaptation for different application types (CRUD vs event-driven vs real-time), legacy application migration strategy. Defines the balance between architectural purity and delivery speed, designs platform solutions for cross-cutting concerns, mentors leads on adapting architecture to business context.
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.
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.
Shapes the organization's Android platform identity strategy: centralized auth SDK architecture, enterprise IdP integration standards (SAML, OIDC), zero-trust architecture for mobile applications. Defines Passkeys adoption roadmap, designs solutions for complex auth scenarios (step-up authentication, device trust, continuous authentication), manages compliance with security standards.
Benchmarking 1
▼
Understands basic Android application performance metrics: startup time (cold/warm start), APK/AAB size, memory consumption. Uses Android Studio Profiler to view basic metrics, understands what FPS and jank frames indicators mean, knows about ANR (Application Not Responding) and its causes — Main thread blocking for more than 5 seconds.
Sets and tracks performance budgets for Android applications: cold start < 2s, APK size < 15MB, memory < 200MB, frame render < 16ms. Configures Macrobenchmark tests for startup and scroll performance, integrates Firebase Performance Monitoring for production metrics, analyzes APK size via Android Size Analyzer, optimizes resources (WebP, vector drawables, resource shrinking).
Defines performance strategy for the Android team: SLAs for key metrics (startup P95 < 1.5s, crash-free > 99.9%, ANR-free > 99.5%), performance review processes before release. Implements performance testing in CI pipeline, configures dashboards with production metrics by device and API level, defines performance culture — team training, performance champions, regular audits.
Shapes the platform approach to Android performance engineering: budget standards for all applications with device-tier segmentation, performance monitoring infrastructure architecture (custom metrics, real-time alerting, anomaly detection). Defines Baseline Profiles strategy for all applications, designs centralized performance analytics platform, manages investment in performance improvements based on business impact.
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.
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.
Defines Android development quality standards at the organizational level: unified linter configurations for all projects, technical debt metrics, automated quality gates in CI. Shapes the quality culture — mentoring programs, Android developer guilds, architectural decision record (ADR) processes for mobile solutions.
Code Review 1
▼
Participates in Android code review: checks PRs for coding convention compliance (ktlint, naming), reads and understands changes in ViewModel and Compose components. Leaves constructive comments, asks questions about unclear logic, learns from senior developers' comments, reviews small PRs (< 200 lines) focusing on Kotlin code readability.
Conducts Android code reviews: checks architectural compliance (MVVM layers, DI rules), finds potential issues — memory leaks, incorrect lifecycle usage, thread-safety issues. Reviews Compose code for correct recomposition, Room migrations for data safety, Gradle configurations for correctness, leaves actionable comments with examples.
Defines code review process for the Android team: mandatory reviewer rules (CODEOWNERS), review time SLA (< 24h), checklists for different change types (feature, bugfix, refactoring, migration). Implements automated review via Danger/Detekt PR integration, balances thoroughness with velocity, trains the team on constructive code review focusing on learning over criticism.
Shapes the Android organization's code review culture: standards for cross-team review, architectural review board for significant changes, review process effectiveness metrics (review time, rework rate). Designs AI-assisted review pipeline, defines escalation processes for disputed architectural decisions, mentors leads on balancing quality gates and developer velocity.
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.
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.
Shapes the multithreading strategy for the Android platform: architectural solutions for concurrent data access, Mutex/Semaphore usage standards in Kotlin, protocols for working with ContentProvider from multiple processes. Defines background processing policies (WorkManager vs Coroutines vs Services), designs solutions for high-load mobile scenarios.
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.
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.
Shapes the platform E2E strategy for Android: standard test infrastructure for all applications, device farm architecture (Firebase Test Lab / self-hosted), E2E suite stability metrics. Defines test recording and replay strategies for faster creation, designs AI-assisted test generation, manages ROI of E2E testing investments vs manual QA.
General Mobile Practices 4
▼
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.
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.
Defines organization-wide mobile store optimization strategy: evaluates ASO tools and platforms for enterprise adoption, designs cross-platform store presence frameworks, establishes data-driven ASO governance. Shapes industry best practices for app discoverability.
Uses Mobile CI/CD at a basic level. Creates simple screens from design. Understands the application lifecycle.
Configures Gradle-based CI/CD pipelines with automated testing and signing. Implements build flavors for multiple environments. Sets up artifact distribution via Firebase App Distribution or internal tracks.
Defines CI/CD strategy for the Android team: multi-module pipelines with parallel builds, detekt/lint integration in PR checks, automatic release train to Play Store. Implements remote Gradle build cache, configures snapshot testing in CI, defines branch protection and merge policy standards for Android repositories.
Shapes the platform CI/CD infrastructure for Android: unified build system for all applications, self-hosted runners with Android SDK, Gradle Enterprise strategy for build performance monitoring. Designs zero-downtime release processes, defines SLAs for build times, implements canary deployments with automatic rollback based on crash metrics from Firebase.
Uses Mobile Performance at a basic level. Creates simple screens from design. Understands the application lifecycle.
Profiles Android apps with Android Profiler to optimize CPU, memory, and network usage. Reduces jank by optimizing RecyclerView and layout hierarchies. Implements lazy loading and efficient bitmap handling.
Defines performance strategy for the Android team: performance budgets (startup < 1s, frame time < 16ms), Macrobenchmark implementation for automatic regression tracking. Configures Firebase Performance Monitoring for production metrics, defines SLAs for ANR rate and crash rate, trains the team on profiling and optimization using Perfetto and System Trace.
Shapes the platform approach to Android performance: standards for different device categories (low-end, mid, flagship), architectural solutions for 60fps rendering of complex UIs, baseline profiles strategy for all applications. Designs production performance monitoring system (custom metrics, percentiles, device segmentation), defines processes for improving performance culture.
Uses Mobile Security at a basic level. Creates simple screens from design. Understands the application lifecycle.
Implements Android security best practices including EncryptedSharedPreferences and certificate pinning. Configures ProGuard/R8 obfuscation rules. Handles biometric authentication with BiometricPrompt API.
Defines security standards for the Android team's applications: OWASP MASVS compliance checklist, security review processes for each release, secrets management strategy (API keys, signing keys). Implements SafetyNet/Play Integrity API for attestation, configures Network Security Config, trains the team on protecting against typical attacks — MITM, injection, data leakage.
Shapes the organization's Android platform security strategy: zero-trust architecture for mobile applications, data encryption standards at-rest and in-transit, incident response protocols. Designs compliance solutions (GDPR, PCI DSS on mobile), defines penetration testing processes, manages bug bounty program for mobile applications.
Memory Management 1
▼
Understands the fundamentals of Memory Management at a basic level. Applies simple concepts in work tasks using Kotlin. Follows recommendations from senior developers when solving problems.
Understands Android memory model: heap vs stack, garbage collection (ART GC), and object lifecycle. Identifies memory leaks using Android Profiler and LeakCanary. Manages bitmap memory efficiently with proper recycling and sampling. Uses WeakReferences for caches and avoids Activity context leaks in long-lived objects.
Manages memory in Android team applications: Bitmap handling standards (inSampleSize, pools), profiling via Memory Profiler in Android Studio, leak prevention strategies via LeakCanary. Defines object lifecycle rules, WeakReference patterns for callbacks, GC pause optimization for smooth UI rendering.
Shapes the platform memory management strategy for Android: memory budget standards for different device categories, image caching policies (Coil/Glide), architectural solutions for working with large heap. Designs production OOM crash monitoring, defines memory consumption metrics and alerts, mentors leads on optimization for low-end devices.
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.
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.
Shapes the platform QA strategy for Android: test infrastructure architecture (cloud device labs, local device farms), quality gate standards by metrics (crash-free > 99.9%, ANR-free > 99.5%). Defines shift-left testing strategy, designs ML-powered test prioritization based on changed code, manages the balance between automated and manual testing.
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.
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.
Shapes the platform standard for data handling in Android: unified networking module for all applications, client-side API versioning protocols, strategies for migrating between API versions. Defines architecture for complex data-flow scenarios — real-time via WebSocket, GraphQL subscriptions, Server-Sent Events on mobile devices.