Principal Android Engineer

Arlo•Milpitas, CA

13d•$215,000 - $295,000

About The Position

Arlo is seeking a Principal Android Engineer to set the technical direction for the Arlo Android app and its team. This is a hands-on leadership role where you will actively contribute to the codebase while also elevating the team's architecture, quality, and engineering practices. You will own the architectural vision, lead by example, tackle complex technical challenges, drive large-scale refactors, define engineering standards, mentor engineers, and collaborate with cross-functional teams. A key aspect of this role involves strategizing and implementing the use of AI coding tools to enhance team productivity and code quality, while establishing guardrails to maintain high standards. The ideal candidate will have deep expertise in Android development, modern app architecture, quality and delivery practices, and leadership. Experience with real-time media, IoT, reliable notifications, background services, security, and networking robustness is highly valued.

Requirements

Expert-level Kotlin, including coroutines and Flow for structured concurrency and reactive state.
Deep knowledge of the Android framework and platform internals: the activity/fragment and component lifecycles, process death and state restoration, the threading model, and how the system schedules and kills work.
Strong command of Jetpack libraries (Compose, ViewModel, Navigation, Room, WorkManager, DataStore, Media3/ExoPlayer).
Modern app architecture in practice — unidirectional data flow (MVVM/MVI), clean separation of concerns, and well-defined module boundaries — with the judgment to know when to bend the rules.
Proven experience designing and evolving a large, multi-module Android codebase, including Gradle build configuration and build-time optimization.
Dependency injection at scale (Hilt/Dagger) and the trade-offs involved.
A track record of leading migrations and refactors in a live, high-traffic app without halting feature delivery.
A real testing strategy across unit, integration, and UI layers (JUnit, Turbine, Compose testing, Espresso/UI Automator), and the discipline to make tests a help rather than a burden.
Hands-on with CI/CD for mobile (build pipelines, automated checks, staged/phased rollouts, feature flags).
Performance engineering: profiling and fixing jank, memory leaks, slow cold starts, and excessive wakeups/battery drain using tools like the Android Studio profilers, Perfetto/systrace, Baseline Profiles, and Macrobenchmark.
The ability to influence without authority — aligning engineers around a direction through clear writing, strong design reviews, and credible code.
Excellent technical communication: you can make a complex trade-off legible to both a junior engineer and a VP.
A mentoring instinct and genuine investment in growing the people around you.
Treating AI coding tools as an engineering responsibility to make the team meaningfully faster and stronger, without letting AI-generated code erode architecture, readability, or long-term maintainability.
Real-time media & streaming — WebRTC, RTSP, or peer-to-peer video; low-latency live view; two-way audio; and media playback/seek for recorded events (Media3/ExoPlayer, codecs, adaptive bitrate).
IoT / connected-device experience — device provisioning and onboarding flows over BLE and Wi-Fi, pairing, firmware-update UX, and handling the long tail of connectivity and state-sync edge cases.
Reliable notifications — FCM/push at scale where a missed or delayed alert is a real problem, including notification channels, priority, and the realities of OEM background restrictions and Doze/App Standby.
Background & foreground services — long-running and time-sensitive work under modern Android background-execution limits, with careful attention to battery.
Security & privacy on-device — encryption, secure credential and token storage (Keystore, EncryptedSharedPreferences/DataStore), biometric auth, and certificate handling.
Networking robustness — designing for offline-first behavior, retries, backoff, and graceful degradation on poor connections.
Resilience across the device matrix — handling fragmentation across OEMs, OS versions, and screen sizes, including aggressive battery managers on certain manufacturers.

Nice To Haves

Experience sharing logic or code across iOS and Android.
Contributions to open source, public technical writing, or conference talks.
Familiarity with the broader smart-home ecosystem (Matter, Google Home / Alexa integrations, widgets, Wear OS, or Android TV/largescreen surfaces).
Backend or firmware fluency sufficient to collaborate deeply across the stack.

Responsibilities

Own the architectural vision for the Android app and drive it from proposal to production.
Lead by example in the codebase: ship meaningful features and platform improvements yourself, and set the standard for what "good" looks like through your own pull requests.
Tackle the hardest technical problems on the app — real-time video streaming, latency, reliability of security notifications, background execution, and battery/performance constraints.
Drive large-scale refactors and migrations (e.g., to Jetpack Compose, to a cleaner module graph, to modern async patterns) with a pragmatic, incremental plan that keeps the app shippable throughout.
Define and uphold engineering standards: testing strategy, code review culture, CI/CD, release health, crash-free rates, and performance budgets.
Mentor and grow engineers across levels — through pairing, design reviews, RFCs, and day-to-day technical guidance.
Partner closely with product, design, backend/firmware, and QA to shape what's feasible and sequence work sensibly across teams.
Make build-vs-buy and technology-selection decisions, and document the reasoning so the team can move fast with confidence.
Champion observability and debuggability — logging, tracing, crash and ANR triage, and the tooling that makes production issues findable.
Set the team's strategy for AI-assisted development — where AI tools genuinely accelerate work (boilerplate, test scaffolding, migrations, refactors, documentation, exploration) and where human judgment must stay in the loop.
Define the guardrails that keep quality high: review standards for AI-generated code, architectural and security boundaries it must respect, and clear expectations that engineers understand and own every line they ship regardless of how it was produced.
Build the practices and prompts/patterns that let the team get reliable results from AI tools, and codify them so the whole team benefits rather than each engineer reinventing them.
Use AI to raise the floor and the ceiling — accelerating ramp-up for newer engineers while freeing senior engineers to focus on the hard design problems — and mentor the team on using these tools to grow their skills, not bypass them.
Evaluate and pilot AI tooling pragmatically, measuring real impact on delivery speed and code health, and retiring what doesn't earn its place.
Guard against the failure modes — subtle bugs, insecure patterns, architectural drift, and over-reliance — by ensuring AI output is always held to the same testing, review, and design bar as anything else.