AI Coding Assistants 1
▼
Uses GitHub Copilot for React Native code auto-completion — components, styles, hooks. Accepts/rejects Copilot suggestions with context understanding. Uses Copilot Chat to explain unfamiliar React Native patterns. Verifies generated code for correctness and type safety.
Effectively applies Copilot for React Native tasks — generating tests, types, utilities. Uses Copilot for writing platform-specific iOS/Android code. Configures context through comments and JSDoc for more accurate suggestions. Applies Copilot Chat for refactoring and code review.
Integrates Copilot into advanced React Native workflows — generating migrations, EAS configurations, native modules. Uses Copilot Workspace for feature architecture design. Analyzes Copilot suggestion quality for mobile development, forms usage best practices.
Defines the Copilot usage strategy for the mobile team. Establishes guidelines — settings, limitations, review process for AI-generated code. Evaluates the impact on developer productivity. Implements Copilot Business/Enterprise considering mobile code security.
Algorithms & Data Structures 2
▼
Understands basic sorting and search algorithms, applies them when working with FlatList and SectionList in React Native. Evaluates O(n) complexity of simple array operations for list rendering. Uses Set and Map for filtering duplicates when processing API data.
Optimizes data processing algorithms for resource-constrained mobile devices. Applies memoization and computation caching in useMemo/useCallback to prevent unnecessary re-renders. Selects optimal data structures for state normalization in Zustand/Jotai.
Designs efficient algorithms for handling large datasets in mobile applications — virtualization, pagination, incremental loading. Profiles algorithmic complexity via Flipper and Hermes profiler. Optimizes critical data processing paths.
Defines algorithmic efficiency standards for the team's React Native projects. Implements performance budgets for data processing in mobile apps. Conducts architectural decision reviews focused on computational complexity and device memory consumption.
Works with arrays and objects for managing data in React Native components. Uses Map for caching and Set for unique values. Understands app state structure — nested objects, normalized data from REST API for list display.
Designs normalized data structures for state management in Zustand/Jotai. Applies trees and graphs for React Navigation stacks. Uses queues for managing offline operations and data synchronization via AsyncStorage/MMKV.
Develops optimal data storage structures for MMKV and AsyncStorage considering mobile device constraints. Designs cache strategies with TanStack Query using proper keys and invalidation. Optimizes structures to minimize re-renders in large lists.
Defines data modeling standards for the team's React Native apps. Reviews data storage architecture — choosing between AsyncStorage, MMKV, SQLite, WatermelonDB. Implements normalization patterns for predictable state management in large-scale mobile projects.
API Protocols 1
▼
Uses WebSocket connections in React Native for basic real-time functionality — chat, notifications. Connects to WebSocket servers, handles incoming messages, displays updates in UI. Understands the connection lifecycle — open, message, error, close.
Implements robust WebSocket integration in React Native — automatic reconnection, heartbeat, exponential backoff. Manages connection state during app background/foreground transitions. Types WebSocket messages via TypeScript. Integrates Socket.IO for complex scenarios.
Architects real-time React Native application infrastructure on WebSocket. Implements patterns — event sourcing for synchronization, pub/sub for channels, presence for online status. Optimizes battery and traffic — throttling, smart reconnection on network change (Wi-Fi/cellular).
Defines the real-time communication strategy for mobile products. Establishes WebSocket integration architecture — protocols, message formats, error handling. Reviews impact on device performance and battery. Coordinates WebSocket infrastructure with the backend team.
Application Security 1
▼
Follows basic security practices in React Native — does not store secrets in code, uses .env for configuration. Understands the dangers of storing tokens in AsyncStorage. Uses HTTPS for all requests. Validates user input. Does not log sensitive data in production.
Implements secure storage in React Native — Keychain (iOS) and Keystore (Android) via react-native-keychain. Integrates certificate pinning for MITM protection. Obfuscates JS bundle via Hermes bytecode. Conducts dependency security reviews with npm audit. Uses ProGuard for Android.
Architects React Native application security — data protection at rest and in transit, biometric authentication, jailbreak/root detection. Implements RASP (Runtime Application Self-Protection). Conducts threat modeling for mobile applications against OWASP Mobile Top 10.
Defines the security strategy for the team's mobile apps. Establishes secure coding guidelines for React Native — code review checklist, mandatory security checks. Implements SAST/DAST in the CI/CD pipeline. Coordinates penetration testing and security audits of mobile apps.
Architecture Patterns 1
▼
Follows clean architecture principles in React Native projects — separating UI and logic through custom hooks. Does not place business logic in components. Understands layer dependencies — screens depend on hooks, hooks on services, services on API client. Follows naming conventions.
Applies Clean Architecture in React Native — Domain layer (entities, use cases), Data layer (repositories, API), Presentation layer (screens, components). Implements Dependency Inversion through service abstractions. Isolates platform-specific code via adapters for testability.
Architects Clean Architecture for large-scale React Native applications. Defines module boundaries and inter-layer contracts. Implements the Use Case pattern for business logic. Ensures domain layer independence from the React Native framework. Designs a DI container for dependency management.
Defines Clean Architecture standards for mobile projects. Establishes guidelines — module structure, dependency rules, architectural tests (ArchUnit). Reviews architectural boundary compliance. Mentors the team on applying Clean Architecture in the React Native context.
CI/CD 1
▼
Understands the basic CI/CD pipeline structure for React Native — build, tests, linting. Runs existing GitHub Actions workflows for pull request verification. Reads build logs, finds reasons for test failures. Uses EAS Build via CLI for local and cloud builds.
Configures GitHub Actions for React Native — parallel jobs for iOS/Android, caching node_modules and Gradle/CocoaPods. Integrates EAS Build into the pipeline, configures auto-deploy to TestFlight and Firebase App Distribution. Configures CodePush for OTA updates from CI.
Architects CI/CD pipeline for React Native monorepo — matrix builds, conditional workflows based on changed modules. Optimizes build time — parallelization, caching, incremental builds. Integrates Detox E2E tests in CI with emulators. Configures release automation.
Defines the DevOps strategy for mobile development. Establishes pipelines from commit to production — feature branches, staging, release candidates. Implements automated release management — versioning, changelog, code signing. Coordinates CI/CD with platform-specific requirements.
Clean Code & Refactoring 1
▼
Follows the React Native project code style guide — ESLint, Prettier. Writes readable TypeScript code with clear component and hook names. Structures files by Feature-Sliced or modular architecture. Decomposes large screens into reusable components.
Configures ESLint with React Native and React Hooks rules. Applies strict TypeScript for type safety. Refactors components following Single Responsibility — extracts logic into custom hooks, styles into StyleSheet. Implements Husky pre-commit hooks for automated code checks.
Architects React Native codebase with scalability in mind — modularity, clean layer boundaries. Implements code quality metrics — cyclomatic complexity, code coverage. Optimizes Developer Experience through component generators and templates.
Defines code quality standards for the team's React Native projects. Establishes code review guidelines with checklists for mobile development. Implements automated checks — SonarQube, custom ESLint rules. Mentors developers on clean code practices in the React Native context.
Code Review 1
▼
Participates in code review of React Native projects — reads diffs, leaves constructive comments. Checks basic aspects — TypeScript types, styles, naming conventions. Responds to review comments and makes fixes. Learns from reviews by more experienced developers.
Conducts quality code reviews for React Native — checks component architecture, hook correctness, FlatList performance. Identifies potential memory leaks, missing cleanup in useEffect. Reviews platform-specific iOS/Android code. Provides actionable recommendations.
Reviews architectural decisions in React Native — navigation structure, state management, native modules. Evaluates performance — unnecessary re-renders, heavy computations on JS thread. Checks security — secret storage, certificate pinning. Creates checklists for typical PRs.
Defines the code review process for the mobile team — guidelines, checklists, review SLA. Builds a culture of constructive review — focus on architecture and business logic. Implements automated checks — Danger.js, custom lint rules. Mentors reviewers on feedback quality.
Concurrency & Parallelism 1
▼
Uses async/await for API requests in React Native. Understands Promises for working with fetch and axios. Handles basic network request errors with try/catch. Uses useEffect for async data loading on screen mount and displays loading states.
Manages complex async flows — parallel requests via Promise.all, dependent request chains. Integrates TanStack Query for caching and automatic refetching. Handles race conditions during screen navigation, cancels requests via AbortController.
Architects async operation infrastructure — offline request queues, retry strategies, optimistic updates. Optimizes concurrent operations considering mobile network constraints. Implements patterns for WebSocket and real-time data handling in React Native applications.
Defines asynchronous programming standards for the React Native team. Establishes error handling patterns for network, timeouts, retries. Reviews background task implementation, push notifications, background fetch. Implements best practices for async state management via TanStack Query.
Cross-Platform Mobile 1
▼
Uses React Native at a basic level. Creates simple screens from designs. Understands the application lifecycle.
Independently implements complex screens with React Native. Optimizes performance and memory consumption.
Architects mobile application with React Native. Optimizes performance for low-end devices. Implements CI/CD for mobile development. Mentors the team.
Defines the technical strategy for React Native development — migration to New Architecture (Fabric, TurboModules), Hermes updates, Expo integration. Establishes coding standards, architectural templates, code review processes. Mentors the team on advanced techniques.
General Mobile Practices 1
▼
Understands basic ASO concepts for React Native apps: keyword optimization for dual-platform listings, store-specific metadata requirements for iOS and Android, screenshot asset preparation workflow. Follows team guidelines for cross-platform store listing management.
Independently manages ASO for React Native apps on both platforms: differentiates keyword strategies for App Store vs Google Play, optimizes store listings for platform-specific conversion, runs A/B tests on creatives. Understands cross-platform ranking differences and review workflows.
Designs unified ASO strategy for React Native cross-platform products: builds store performance analytics, implements automated listing experiments across platforms, analyzes iOS vs Android conversion funnel differences. Mentors team on platform-specific store optimization nuances.
Defines ASO framework for React Native mobile portfolio: coordinates store optimization across platforms and marketing teams, establishes unified metadata workflows, implements keyword overlap and cannibalization analysis. Leads cross-platform store presence strategy.
Integration Testing 1
▼
Writes integration tests for React Native screens — component interaction, navigation between screens. Tests forms with data input and submit via React Native Testing Library. Verifies correct data display from mocked API. Understands the difference between unit vs integration tests.
Tests React Native component integration with state management and navigation — wrappers with Zustand Provider, NavigationContainer. Mocks API responses with MSW for realistic scenarios. Tests offline behavior and error states. Integrates tests into CI/CD pipeline with reports.
Architects integration testing strategy — end-to-end feature testing within the JS layer. Implements contract testing between React Native client and API. Configures test environment with native module mocks, navigation, storage. Optimizes test reliability and speed.
Defines the integration testing strategy for mobile projects. Establishes guidelines — what to cover with integration tests, boundary with E2E. Implements test environment and fixture standards. Coordinates cross-platform iOS/Android compatibility testing.
OOP & Design Patterns 1
▼
Understands basic OOP concepts in TypeScript: classes, interfaces, type composition. Applies simple SOLID principles following React Native project structure. Follows team patterns for hook-based service abstractions and native module bridge design.
Independently applies OOP/SOLID in React Native: proper hook composition and service abstraction, interface-based native module bridges, single responsibility in screen components and navigation logic. Understands trade-offs between class components and functional/hook-based patterns in React Native.
Applies OOP/SOLID in React Native architecture: clean abstractions for native module interfaces, dependency inversion for platform-specific implementations, interface segregation for service layer contracts. Designs modular cross-platform architectures with proper separation between shared business logic and platform-specific UI/behavior.
Defines SOLID and OOP application standards in React Native projects — Single Responsibility for hooks and services, Dependency Inversion for abstracting platform-specific code. Reviews architecture for principle compliance when integrating native iOS/Android modules.
React Ecosystem 1
▼
Uses core React concepts including hooks, props, and state in React Native context. Creates simple mobile screens following platform design guidelines. Understands component lifecycle and basic navigation patterns.
Implements complex mobile components bridging React core patterns with native platform features. Optimizes FlatList rendering and manages state with Redux or Zustand. Tests components with Jest and React Native Testing Library.
Has deep expertise in React Core. Designs solutions for production systems. Optimizes and scales. Mentors the team.
Defines architectural standards for React usage in mobile applications. Establishes guidelines for re-render optimization and component lifecycle management. Reviews React pattern application considering React Native and New Architecture (Fabric) specifics.
Specialized Testing 1
▼
Understands the fundamentals of mobile testing in React Native. Writes basic Detox end-to-end tests and component tests. Validates native bridge interactions on both platforms. Applies standard practices for cross-platform test sharing and regression checking in daily work.
Tests React Native applications on real devices and emulators — verifies platform-specific iOS/Android behavior. Configures debug tools — Flipper, React DevTools. Conducts manual testing — deep links, push notifications, background/foreground transitions.
Architects comprehensive mobile testing strategy — unit, integration, E2E, visual regression, performance testing. Implements automation on device farms — BrowserStack, Firebase Test Lab. Tests mobile-specific scenarios — network, battery, memory, call interruptions.
Defines the mobile testing strategy for the team's products. Establishes test matrix — devices, OS versions, resolutions. Coordinates QA process — when manual, when automated testing. Implements real-user experience monitoring via Sentry, Firebase Crashlytics.
State Management 1
▼
Uses useState and useContext for managing local state in React Native components. Understands lifting state up between screens. Applies basic Zustand store for global state — authentication, theme, app language.
Architects state with Zustand — slice separation, subscriptions, middleware. Integrates TanStack Query for server state, Zustand/Jotai for client state. Implements persist with MMKV for offline access. Optimizes re-renders through selectors and shallow comparison.
Architects state management for large-scale React Native applications. Implements patterns — server state vs client state, optimistic updates, derived state via Jotai atoms. Designs state synchronization between devices and offline-first persistence.
Defines the state management strategy for the team's mobile apps. Establishes tool selection guidelines — Zustand vs Jotai vs Redux Toolkit. Reviews state architecture for memory leaks and unnecessary re-renders. Implements state performance metrics.
System Design 1
▼
Understands basic React Native application architecture — separation into screens, components, services. Follows project file structure — screens, components, hooks, services, navigation. Understands client-server architecture and the mobile app's role as a REST/GraphQL API client.
Designs React Native module architecture — Feature-Sliced or modular structure. Separates the application into layers: UI, business logic, data layer, navigation. Applies dependency injection for testability. Designs offline-first scenarios with data caching and synchronization.
Architects large-scale React Native application — monorepo with shared packages, modular architecture with lazy loading. Defines boundaries between JS and Native layers. Designs migration to New Architecture. Develops ADRs (Architecture Decision Records) for key decisions.
Defines the architectural strategy for the team's mobile apps. Establishes React Native reference architecture — layers, modules, dependencies. Conducts architecture reviews for new features and projects. Determines trade-offs between monolith and micro-frontends in the mobile context.