Senior Android Developer

We're hiring an Android developer who can build a complete app from Figma to the Play Store. No templates, no legacy code. You'll own the Android codebase end to end: architecture, UI, networking, state, real-time updates, and release management. This is a build-from-scratch environment using
Kotlin

,
Jetpack Compose

,
REST APIs

, and
Pusher

for real-time sync.

You must know what good Android code looks like in 2025 and write it that way from the start.

Core Responsibilities

• Build the
  entire app UI

using
Jetpack Compose

.  no XML, no fragments. Implement pixel-perfect screens from Figma with attention to animations, transitions, adaptive layouts, and dark mode.
- Architect the app with
MVVM + clean architecture principles

, using
ViewModel

,
StateFlow

, and
Repository

layers.
- Integrate with
custom REST APIs

using Retrofit + OkHttp + Moshi or Kotlinx Serialisation. Handle auth, caching, pagination, error states, and offline sync.
- Implement
real-time communication

using
Pusher Channels

(Socket-based updates, presence channels, chat, or live data events).
- Handle push notifications, deep links, and background updates properly.
- Ensure
edge-to-edge layout

support, draw behind system bars, manage IME insets, handle gesture navigation, and follow Android 15 guidelines.
- Maintain
test coverage

: Unit tests, Compose UI tests, and instrumented tests.
- Own the
Play Store pipeline

: signing, versioning, build variants (staging, production), changelogs, and rollouts.
- Optimize for
performance, battery, and memory

using profiling tools and monitoring.
- Stay up to date with
Android 15 (API 35)

requirements and Google Play compliance rules.
- Document architecture, API flows, and maintain consistent code standards.
- Work closely with backend engineers to refine REST contracts and ensure API consistency.

Minimum Requirements

• 3+ years of hands-on Android experience (Kotlin only).
• Strong command of
  Jetpack Compose

(including state management, recomposition control, and modifiers).
- Proficiency with
Android 15 SDK

, AndroidX libraries, and modern dependency management (Gradle KTS).
- Practical experience integrating
REST APIs

using
Retrofit

,
OkHttp

, and structured response handling.
- Experience with
Pusher Channels

or equivalent (Socket.IO, WebSockets, Firebase RTDB).
- Skilled with
Kotlin Coroutines

,
Flow

, and structured concurrency.
- Understand and apply
Clean Architecture

with modular code.
- Strong understanding of lifecycle, navigation, dependency injection (Hilt or Koin), and offline-first design.
- Strong debugging and profiling skills — you can find a memory leak or ANR without guessing.
- Comfortable with
Play Store

releases, build signing, and release management.
- Able to work independently — given a Figma file and a backend endpoint, you can ship a production-ready feature.

Preferred but Not Mandatory

• Experience with
  Jetpack Compose animation APIs

and
Accompanist

.
- Worked with
real-time chat

,
notifications

, or
live dashboards

.
- Experience with
modularization

, multi-module builds, or feature flags.
- Familiarity with
backend REST design

or light Node/Kotlin backend work.
- Exposure to CI/CD (GitHub Actions, Bitrise, etc.).
- A published app on Play Store that targets API 34 or 35.

What We Expect

We're not looking for someone to "maintain an app."

We're looking for someone to
build

one cleanly, modularly, and future-proof.

You should:

• Write code that reads like documentation.
• Argue for or against architectural decisions with reasoning, not ego.
• Respect deadlines but never at the cost of code rot.
• Deliver something that passes Play Store review on first submission.
• Treat performance and battery like first-class citizens.
• Understand that UI polish is not "extra," it's expected.

Bonus if You

• Can set up your own backend mocks for local testing.
• Know Compose performance pitfalls (unnecessary recomposition, remember misuse, snapshot invalidation).
• Contribute to libraries or open source.
• Have opinions about build speed, architecture boundaries, and testing discipline. And can back them up

Tools You'll Use

• Kotlin 2.x, Android Studio Koala+, Jetpack Compose 1.9+
• Material 3 / Accompanist Libs
• Retrofit + OkHttp + Moshi/Kotlinx Serialization
• Coroutines / Flow / StateFlow
• Hilt / Koin DI
• Pusher Channels (Realtime Events)
• JUnit / Compose Test / MockK
• Gradle KTS

Outcome

When you're done, we'll have an Android app that:

• Mirrors the Figma design pixel for pixel.
• Talks seamlessly with REST backend and Pusher real-time events.
• Passes Google Play's API 35+ review without warnings.
• Runs edge-to-edge, fluid, stable, and ready for scale.