MTS-2 at Panasonic Avionics

Hello, I'm

Atharva
Mahamuni

Android Developer · IFE Systems

I build Android apps in Kotlin and Jetpack Compose with MVVM and Clean Architecture. Today that means in-flight entertainment apps on seat-back screens across 10 commercial aircraft; before that, an internal app for the National Stock Exchange. I own features end to end, from UI and API integration to testing, CI/CD and release.

  • Clean Architecture
  • IFE Systems
  • Jetpack Compose
  • Agentic Coding / AI
  • Kotlin Multiplatform
4
years building
Android apps
10
premium aircraft
running my IFE work
3
product lines on a
shared framework
Atharva Mahamuni smiling outdoors in Pune with green hills behind

Experience

Where I've worked

Panasonic Avionics Corporation

Pune, India

  • MTS-2, Android DeveloperJul 2026 – Present
  • MTS-1, Android DeveloperJan 2025 – Jul 2026
  • Developed an Android in-flight entertainment app for seat-back screens across a fleet of 10 premium aircraft, including video playback with ExoPlayer/Media3.
  • Contributed to a shared Android framework built on Clean Architecture and SOLID principles, used across 3 product lines.
  • Work across RxJava and Kotlin Coroutines/Flow code, keeping business logic in repositories, separate from the UI.
  • Maintain Gradle Kotlin DSL builds with version catalogs, build flavors and signing configs, with CI on Jenkins and GitLab CI.

Capgemini Client: National Stock Exchange

Pune, India

  • Associate Consultant, Android DeveloperOct 2022 – Jan 2025
  • Built an Android app for NSE's performance testing that runs load tests through REST APIs on a wrapper backend over Apache JMeter.
  • Integrated APIs with Retrofit and StateFlow, with clear loading and error states in Jetpack Compose screens.
  • Secured app access with biometric authentication and stored tokens in the Android Keystore.
  • Improved cold-start time with Baseline Profiles and by deferring non-critical Hilt and SDK initialization.
  • Tracked and fixed crashes and memory leaks with Firebase Crashlytics and LeakCanary.
  • Migrated legacy Java code to Kotlin and MVVM, and added unit tests (JUnit, Mockito) and UI tests (Espresso).

Interactive Motion Studio

Android Architecture & System Internals

Explore the reactive Unidirectional Data Flow (UDF) pipeline in action, inspect the full Android OS hardware-to-UI stack, and compare architectural patterns.

Android 14 System Bus · Clean Architecture & MVI Engine

Trigger a user interaction below to watch immutable events propagate through the architectural pipeline in real-time, executing use cases, querying offline databases, and emitting fresh UiState to Jetpack Compose.

01 · Intent Compose

Jetpack Compose UI

User taps button; declarative composable emits immutable UiIntent.

READY
02 · Reducer ViewModel

StateFlow Reducer

Dispatches on CoroutineScope; emits optimistic loading state.

LISTENING
03 · Logic Domain

Clean UseCases

Pure Kotlin business rules, license validation, and data transformation.

STANDBY
04 · Storage Data Layer

Room DB & Retrofit

Single source of truth: local SQLite cache with network fallback.

CACHED
05 · Output Media3 / HAL

Hardware & Surface

ExoPlayer hardware video decoding & final UiState render.

ACTIVE
MVI Event Pipeline · Ready
// Jetpack Compose Seat-Back UI Layer
@Composable
fun SeatBackScreen(
    viewModel: FlightViewModel = hiltViewModel()
) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()
    FlightTelemetryHUD(
        altitude = state.altitude,
        speed = state.groundSpeed,
        route = state.route
    )
}
05 · Jetpack Compose & UI Toolkit 120Hz VSync

Declarative rendering tree, Recomposition smart skipping, Snapshot state observation, and layout passes.

04 · Android Framework & ART Runtime Zygote & JVM

Ahead-of-time (AOT) compilation, Baseline Profiles, ActivityManager, WindowManager, and Coroutine dispatchers.

03 · Native C++ & Media HAL ExoPlayer C++

SurfaceFlinger display compositor, AudioFlinger, Media3 hardware codecs, DRM Widevine L1, and Keystore crypto.

02 · Linux Kernel & Binder IPC Process Bus

Low-latency inter-process communication (IPC) via Binder, memory management (ashmem), and hardware power governors.

01 · SoC Silicon & Hardware ARM Octa-Core

Adreno GPU, Hardware Video Processing Unit (VPU 4K HEVC), Bluetooth LE controller, and seat-back touch digitizer.

Panasonic Avionics · Seat-Back Display

05 · Jetpack Compose & UI Toolkit

Designed with fine-grained recomposition boundaries to ensure seat-back entertainment displays run locked at 60/120fps with zero frame drops during turbulence or high UI activity.

Smart Recomposition

Immutable data classes prevent unneeded layout calculations across passenger screens.

Baseline Profiles

Pre-compiled Ahead-Of-Time code delivers 320ms cold starts on aircraft reboot cycles.

MVVM

Model-View-ViewModel

Separates presentation from data using observable state holders. Ideal for modular feature screens with rapid iteration.

View (UI) ⇆ ViewModel ⇆ Repository
• Observer: StateFlow / LiveData
• Concurrency: CoroutineScope

MVI

Model-View-Intent · Unidirectional

Enforces a single immutable State and a pure reducer function. Guarantees deterministic state reproducibility and eliminates concurrency race conditions.

Intent ➔ Reducer ➔ State ➔ Render
• UDF: Single Source of Truth
• Testing: Deterministic & Replayable

Clean Architecture

Separation of Concerns & SOLID

Isolates domain business rules from external frameworks. Enables sharing a unified Android core across Panasonic's 3 distinct IFE product lines.

UI ➔ ViewModel ➔ UseCase ➔ Data
• Inversion of Control: Dagger Hilt
• 100% Unit Testable Domain Layer

Projects

Things I've built

Android

ToyTools for Android

Everyday utility tools on the phone built with Clean Architecture, Kotlin Coroutines, and Jetpack Compose.

Kotlin · Jetpack Compose · MVVM

Android · IoT

IoT Robot Controller

An Android app that controls a NodeMCU-based robot over Bluetooth, built for the college Automation and Robotics Cell.

Android · Bluetooth LE · Microcontrollers

Full stack

Spotify full-stack app

A Spotify-style full-stack app built from scratch, with a separate frontend and an API backend on MySQL.

JavaScript · Node.js · MySQL

Skills & tools

Languages
KotlinJavaTypeScriptSQL
Android
Android SDKJetpack ComposeViewModelNavigationRoomWorkManagerMaterial Design 3ExoPlayer/Media3Bluetooth LE
Architecture
MVVMClean ArchitectureRepository PatternSingletonSOLIDModular Architecture
Async & data
CoroutinesFlow/StateFlowRxJavaRetrofitREST APIsDagger HiltSQLiteFirebase
Testing
JUnitMockitoEspressoCompose UI TestingCrashlyticsLeakCanary
Build & CI/CD
Gradle Kotlin DSLVersion CatalogsBuild Flavors & SigningFastlaneGitHub ActionsJenkinsGitLab CIPlay Store
Tools
Android StudioGitJiraAgile/ScrumCode Review
Familiar with
Kotlin MultiplatformCompose MultiplatformThree.js / WebGL

Education

Academic background

B.Tech in Computer Science and Engineering

Annasaheb Dange College of Engineering and Technology (ADCET), Sangli

2018 – 2022
CGPA 7.9

Machine Readable & AI Discovery

Let's build something.

The best way to reach me is email or X. I'm also active on LinkedIn and GitHub.