Senior Android Developer

About Us:

Fluent Health is a dynamic healthcare startup revolutionizing how you manage your healthcare and that of your family. The company will provide customers with high-quality, personalized options, credible information through trustworthy content, and absolute privacy. To assist us in our growth journey, we are seeking a highly motivated and experienced Senior Android Developer to play a pivotal role in future success.

Website Link- https://fluentinhealth.com/

Github Link- https://github.com/fluent-health

Job Description:

We're hiring a Senior Android Engineer to own and evolve our existing native Android application, a production app already in users' hands while we make a deliberate strategic shift toward React Native as our cross-platform direction. You'll be a proper Android expert first, and a capable React Native engineer alongside that. Both matter; neither is optional.

In practice, that means continuing to ship and harden the native Kotlin app, and contributing meaningfully as we migrate, share, and rebuild parts of the experience in React Native. You'll inherit a working codebase with deliberate decisions in it. Your job is to push it forward, not rewrite it for the sake of rewriting.

We work in an AI-supported engineering workflow. Tools like Claude Code and skill frameworks like Superpowers are part of how we plan, write, review, and ship code day-to-day. Familiarity with these and the judgment to know when to lean on them and when not to is a near-must, not a curiosity.

This is an expert role. We're not looking for someone with potential; we're looking for someone who has done this, knows what good looks like, and walks in with proposed solutions instead of open questions. You'll partner with product, design, backend, ML, QA, and compliance to deliver mobile experiences that hold up in a regulated healthtech context.

Responsibilities:

Native Android (the core of the role):

• Own, evolve, and harden our existing Kotlin Android application performance, stability, architecture, modularization, build health.
• Ship features end-to-end: from product/design intent through to release, monitoring, and the bug reports that come back two weeks later.
• Drive architectural decisions within the app (MVVM / clean architecture, modularization, DI, navigation, state management) and defend them with reasoning, not preference.
• Keep the Jetpack Compose surface area moving forward without breaking the Views/DataBinding code that still works.
• Lead code quality: reviews, automated testing, CI health, release hygiene.

React Native (the strategic direction):

• Contribute to and help shape our React Native footprint as we migrate and build cross-platform.
• Share patterns, components, and infrastructure between native Android and React Native where it makes sense and resist sharing where it doesn't.
• Bring opinions on the bridge layer, native modules, and the realistic limits of cross-platform.

AI-Supported Delivery:

• Use Claude Code, Superpowers, and comparable AI coding agents and skill frameworks as part of your normal workflow for scoping, scaffolding, refactoring, code review, test generation, and documentation.
• Be the person who improves how the team uses these tools: better prompts, better skills, better guardrails, better judgment about when not to use them.
• Maintain the engineering bar. AI accelerates good engineers; it doesn't replace the thinking, and you should treat its output the same way you treat a junior PR review, verify, and take responsibility.

API Integration & Real-time:

• Integrate GraphQL alongside REST APIs; pick the right tool for each surface.
• Build event-driven and real-time features using Pub/Sub patterns and WebSockets where they're warranted.
• Work cleanly against our FHIR-shaped domain data on the client side the data is structured, the UI shouldn't fight it.

Collaboration & Mentorship:

• Partner with backend, ML, design, product, QA, and compliance to deliver features that work end-to-end and stay working.
• Mentor by example. Code reviews, design docs, the way you debug, and the way you prompt are how the bar gets set.
• Contribute to hiring interviews, take-homes, calibration.

Quality, Testing & Observability:

• Treat testing as part of the work, not a thing you do if there's time. Unit tests and integration tests are non-negotiable expectations, not aspirational ones.
• Own the errors your code produces in production. We use Sentry surfaced errors are a queue you actively work, not a wallpaper you stop seeing. Triage, reproduce, fix, verify, close.
• Build with observability in mind from the start: meaningful logs, breadcrumbs, traces, and crash context that future-you and the rest of the team can actually use.

Continuous Improvement:

• Address technical debt proactively. Identify, scope, propose, and close it, don't just file tickets.
• Stay current with the Android ecosystem and the React Native ecosystem; bring forward concrete proposals when something is worth adopting.

Qualifications:

• 6 - 9 years of Android development experience with a real portfolio of production apps you've owned, not just contributed to.
• Expert-level Kotlin; comfortable in Java for the parts of the world that still need it.
• Deep knowledge of the Android ecosystem Jetpack (ViewModel, LiveData/Flow, Room, WorkManager, Navigation), Jetpack Compose, and the older Views/DataBinding stack that real codebases still contain.
• Production experience with React Native not "I built a side project once," but features shipped to real users.
• Strong grip on architecture: MVVM / clean architecture, modularization, DI (Hilt/Dagger/Koin), state management, navigation at scale.
• API integration experience: GraphQL (Apollo or equivalent) and REST (Retrofit, Jackson/Gson).
• Hands-on experience building event-driven and real-time mobile features using Pub/Sub patterns and WebSockets connection lifecycle, reconnection, backpressure, offline behavior, the things that bite in production.
• Testing is non-negotiable. Strong, demonstrable habits around unit testing (JUnit), integration testing, and UI testing (Espresso/Robolectric/Compose testing). We take this seriously; sloppy or skipped testing isn't compatible with this role.
• Sentry (or equivalent error-monitoring platform) used in production and the discipline to actually work the error queue: reproduce, root-cause, fix, verify, close. Surfaced errors are work, not noise.
• Tooling: Android Studio, Gradle (including Kotlin DSL), Git, and a working CI/CD muscle for mobile (signing, distribution, staged rollouts).
• AI-supported engineering: hands-on experience using Claude Code, Superpowers, or comparable AI coding agents and skill frameworks as part of your real day-to-day work not a one-off experiment.