Software Engineer - Mobile Platform

Fabletics•California, CA

38d•$120,000 - $140,000•Remote

About The Position

As a Software Engineer on Mobile App Platform, you'll split your time between the shared systems that power our app, architecture, tooling, and conventions that every feature team relies on, and customer-facing feature work within the app itself. You'll ramp into ownership as you build context: early on that looks like contributing to platform decisions and pairing with existing owners, and over time you'll be the one setting direction. You set the bar for what “well-built platform code” looks like, and you're a force multiplier through the infrastructure you build and the patterns you establish, not just the code you personally ship. Our engineering workflow is already genuinely AI-native. We use Claude Code with custom agent harnesses, structured planning/spec workflows, and adversarial code review as standard parts of how features get built and verified, not an experiment on the side. A real part of this role is pushing that further: refining the harnesses, tightening the review loop, and finding where agentic workflows can take over more of the mechanical work so engineers spend more time on judgment calls. If you're already using tools like this daily and have opinions about how to make them better, that's exactly the kind of hands-on ownership this role is built for. The Mobile App Platform team owns the shared foundation every mobile feature team builds on: core architecture, platform reliability and performance, quality standards, and developer experience. It's a small team, and everything we build gets used by every engineer shipping on the app, across every feature team.

Requirements

5+ years of software engineering experience, with significant depth in React Native (or strong React + mobile platform experience)
Real experience owning shared infrastructure that other engineers depend on. You've built or maintained something used across teams and know the difference between “works for my feature” and “safe for everyone to build on”
Strong TypeScript fundamentals: comfortable in a strictly-typed codebase with zero tolerance for type errors
Deep understanding of React Native fundamentals, including the JS/native bridge, native module boundaries, how to debug issues that span both sides, and how to profile and optimize app performance
Comfortable working across iOS and Android platform differences, including native build tooling (Xcode, Android Studio, Gradle) and the app store release process (App Store Connect, Google Play Console)
Experience with GraphQL and Apollo Client from the client/consumer side, and fluency with modern async/state-management patterns (TanStack Query, Zustand, Redux, or equivalents) with a point of view on their trade-offs. Deeper GraphQL schema or federation experience isn't expected, but is a strong plus if you want to grow into it
Strong testing instincts, ideally including experience building the testing infrastructure itself, not just writing individual tests against it
AI-Forward Mindset: genuine daily use of AI-assisted development tools (Claude Code, Cursor, Copilot, or similar). You already work this way, and you're excited to help shape the tooling for a whole engineering org, not just adopt what's handed to you
Ideal candidate brings foundational AI literacy, including experience using generative AI tools, and a proactive mindset to experiment with new technologies to drive productivity and innovation.
A track record of mentoring engineers and a bias toward raising the bar through code review, not just personal output

Nice To Haves

Experience with native iOS (Swift/Objective-C) or Android (Kotlin/Java) development, since platform work often means dropping below the RN abstraction
Experience with release-safety tooling such as feature-flagging/experimentation platforms (LaunchDarkly or similar) and OTA update systems (CodePush or similar)
Experience with crash reporting / mobile observability tooling (Bugsnag or similar)
Experience with CMS platforms (Builder.io or similar), or comfort learning proprietary/internal content-management tooling
Experience integrating third-party native SDKs (payments, analytics) into a React Native app
Experience with Expo / CNG (Continuous Native Generation) development builds
Interest in growing into adjacent parts of the stack, e.g., our BFF/API layer, GraphQL schema and federation work, search/indexing (Elasticsearch or similar)

Responsibilities

Design, build, and maintain the shared architecture behind our React Native (Expo) app, including navigation, core infrastructure, and design-system primitives, and make the calls on how cross-feature conventions should evolve as the app grows.
Take on customer-facing feature work within the mobile app as a regular part of the role, e.g., push notification experiences, checkout and conversion flows, personalization, and other in-app customer experiences.
Consume and integrate with our internal REST and GraphQL APIs as well as third-party services (payments, CMS, and similar), and help maintain the app-wide state-management patterns that every feature team codes against.
Diagnose and resolve iOS- and Android-specific issues, understand the boundary between JS and native code (native modules, JSI/Turbo Modules), and know when a problem needs native-level debugging vs. a JS-level fix.
Profile and optimize app performance (render performance, list virtualization, startup time, bundle size) using standard React Native tooling.
Build and refine our Claude Code agent workflows (custom subagents, planning/spec tooling, adversarial review) as core platform investment. You're not just using these tools; you're improving them for every engineer on the team.
Maintain shared testing infrastructure (Vitest). Set and enforce the standards around type safety, performance, and test coverage that keep a codebase this size from rotting.
Review code across feature teams, mentor engineers on platform patterns, and raise the technical bar through pairing and architecture guidance, not just ticket-by-ticket feedback.
Partner directly with feature teams to help them apply platform patterns correctly, and treat friction they hit as a signal to fix the platform, not just document a workaround.
Diagnose and resolve production issues rooted in shared/platform code, and participate in on-call rotations.