Skip to content

Pune, India · Senior Android Engineer

I take Android apps from prototype to platform.

platform owner · 50k+ MAU fintech · 5 platforms · one Kotlin codebase · GPS 50% → 95% · crashes -80% · an engineer who writes

5+ years building production Android. I own the platform behind a ~964k-LOC financial SaaS app serving 50,000+ monthly users — I joined it with zero Kotlin in the codebase, and ~87% of the UI layer is Compose today. Location accuracy, crash-free sessions, architecture a team can move fast in.

View résumé

Open to remote (worldwide / India) and hybrid in Pune / Bengaluru

live✎ latest note · Teaching a phone to disbelieve its own GPS▶ play · live Compose editor

// one codebase

Resize the device, not the screenshot

These are the real Kotlin Multiplatform builds, compiled to Wasm and served from this domain. Change the form factor and the Compose layout re-flows at the same window size classes the code branches on.

compact · <600dp

Kursi · Phone · compact · <600dp

// fit check

Hiring? Paste the job description.

My AI assistant reads it against what I've actually shipped and answers the only question that matters: where I fit, and where I don't. No score inflation — the gaps come with the strengths.

score · 0–100, with the bandmatches · each with the evidence behind itgaps · named — never an empty list
answers in the console, streaming
0 / 12,000⌘/Ctrl + Enter analyses

// featured work

Case studies

The work behind the numbers. Ask the chatbot for more depth on any of these.

Mileway home screen — quick actions and 248 km tracked this month
Flagship build

Mileway

46 modules · 5 platforms · offline AI

An open-source app I designed and built end-to-end: mileage, travel & expense tracking that runs entirely offline across Android, iOS, Wear OS, watchOS and Compose Desktop from one shared Kotlin codebase. Zero backend — Room + DataStore only — so the whole thing is reproducible and reviewable by anyone.

Kotlin MultiplatformCompose MultiplatformAndroid · iOS · Wear OS · watchOS · Desktop46 modulesOffline AIOpen source
Full case study →

50% → 95%

Predictive dead reckoning for billing-grade mileage

Field users' trip distances were off by large margins from urban canyons, tunnels, and OEM-throttled location updates.

Tracking accuracy rose from 50% to 95% via staged dead reckoning plus Kalman smoothing, making mileage reliable enough for expense reimbursement.

How I did it
  • Ran staged dead reckoning over the GPS/IMU fix stream, smoothed by a separate 1D Kalman filter to estimate position between fixes.
  • Rejected physically impossible fixes with spike detection, plus gap-filling for weak signal.
  • Ran a foreground service with a floating bubble UI to survive OEM battery restrictions.
LocationDead reckoningKalman filteringForeground services

-80% crashes

Systematic crash triage at 50k-MAU scale

A fast-growing ~964k-LOC app had a crash rate hurting its Play Store rating, driven by untraceable threading bugs.

Crashes fell 80% at 22k DAU; Play Store went 1.6★/67 reviews to 4.5★/27.3K — closing 85% of the gap to a perfect 5.0, +181% rating, 407x review volume.

How I did it
  • Clustered crashes to collapse dozens of stack traces into a handful of root bugs.
  • Reconstructed the user journey before each crash with structured breadcrumb instrumentation.
  • Hunted concurrency bugs: main-thread violations, coroutine race conditions, lifecycle leaks.
CrashlyticsStructured concurrencyCoroutines

~87% UI-layer Compose

The theme platform behind a ~964k-LOC Compose migration

XML views made UI changes slow and inconsistent, and design's theming requests meant touching dozens of files.

Reached ~87% UI-layer Compose coverage (455k of 523k LOC) verified per-screen against the legacy XML baseline; UI development friction dropped 60%.

How I did it
  • Migrated incrementally via interop, keeping Expenses, Travel, and Invoices shipping throughout.
  • Standardized on a single immutable UiState per screen with StateFlow and MVI.
  • Built a Dynamic Theme Engine on CompositionLocal: a server-supplied tenant seed colour resolves into a full Material 3 scheme at runtime (MaterialKolor), with the client owning dark mode, user colour override, palette style, Material You and variant.
Jetpack ComposeMVIDesign systems

858 branches · 80% faster delivery

Configuration-driven pipeline for multi-tenant Android

Every new white-label client meant manually forking, rebranding, and re-releasing the app: weeks of error-prone work, and the constraint that mattered was not building the feature once — it was doing that without forking the codebase per tenant.

858 white-label-named branches across two Android repos carry my commits (459 autos, 399 driver, a subset of the 1,179 total) spanning 150+ client codebases, with delivery time cut 80% versus manual per-client builds.

How I did it
  • Built configuration-driven theming and feature flags so one codebase served every client.
  • Automated per-client signing, asset generation, and Play Store packaging end-to-end.
  • Unified brand tokens and vertical-specific flows into a single reusable app template.
Build systemsMulti-tenantAutomation

// projects & open source

Things I've built

Open-source projects and tooling outside employer work — shipped end-to-end.

Kursi — 13 modules, 4 platforms, 10 bot personas

Kursi

13 modules · 4 platforms · 10 bot personas ]

A Hinglish social-deduction bluffing game of power, satire & second chances. Kursi ke liye kuch bhi karega.

13 modules · 4 platforms

AndroidiOSDesktopWeb Live

Deterministic Kotlin Multiplatform social-deduction game with ISMCTS bot AI, shipped across Android, iOS, Desktop, and Web.

  • Pure (GameState, Intent) → GameState reducer drives the AI, UI, and a future server.
  • ISMCTS AI with 10 bot personas plus a DARBAR social layer for bluffing and alliances.
Kotlin MultiplatformGame engineISMCTS AI
View case study →GitHub
Mileway — 46 modules, 5 platforms, 159 tests

Mileway

46 modules · 5 platforms · 159 tests ]

Offline-first mileage, travel & expense tracker on one Kotlin codebase across Android, iOS, Wear OS, watchOS & Desktop.

36 modules · 13 features · 368 tests

AndroidiOSWear OSwatchOSDesktop Live

Offline-first mileage, travel, and expense tracker spanning five platforms from one Kotlin codebase, zero backend.

  • 46-module clean architecture: 13 feature modules meeting only at the composition root.
  • Real location engine, reimbursement policy engine, durable submit-outbox, and an on-device AI assistant.
Kotlin Multiplatform46 modules5 platformsOpen source
View case study →GitHub PaymentsLab (sibling KMP app)
PaymentsLab — 40 modules, 66 gateways, 5 rails

PaymentsLab

40 modules · 66 gateways · 5 rails ]

An Integration Lab for the Android payments ecosystem: every gateway behind one abstraction, with a live look at what actually happens on each transaction.

40 modules · 66 gateways

AndroidiOS Live

A Kotlin Multiplatform systems showcase: real payment flows across dozens of providers, all behind a single PaymentGateway abstraction, backed by a Ktor server that owns order creation, signature verification and webhook reconciliation.

  • 40-module registry (15 local + 25 composed) spans 66 cataloged payment gateways.
  • Five money-movement rails plus split payments, all idempotency-keyed and MOCK_MODE-honest.
Kotlin Multiplatform40 modules66 gatewaysOpen source
HireSignal — active, 4 PRs merged upstream

HireSignal

Active · 17 PRs merged to public career-ops ]

A native, multiplatform AI career-intelligence engine, and the open-source project it's built on.

A local-first job-search engine — resume onboarding, reverse-ATS discovery, evidence-based fit scoring and tailored résumés — rebuilt from scratch in Kotlin Multiplatform, with its scoring engine ported and verified against the open-source career-ops project I actively contribute to upstream.

  • 25-module Kotlin Multiplatform clean architecture (12 feature + 6 core modules) targeting Android, iOS, Desktop, Web and a Spring Boot 4 server from one shared engine.
  • core:engine is a no-IO module: A–F fit scoring, ATS search, SimHash fingerprinting, and funnel math ported 1:1 from career-ops and verified against its own test vectors.
Kotlin Multiplatform25 modulesOpen-source contributor
This portfolio and Panda, its AI assistant — live

cv-siddharth — this site, and its Compose Multiplatform twin

Live · React on Vercel, CMP across 4 targets ]

The site you're reading, plus Panda the assistant that answers for me — and the whole thing rebuilt a second time in Compose Multiplatform, one commonMain to Web, Desktop, Android and iOS.

An interactive résumé built twice, on purpose. The React 19 original runs on Vercel Edge with a provider-agnostic LLM assistant grounded in this same profile data. The Compose Multiplatform port renders the same portfolio from 16.2k lines of Kotlin to Kotlin/Wasm, Desktop, Android and iOS — an honest test of how far CMP reaches on the web, including where it doesn't.

  • Two full implementations of one portfolio — the same content rendered by React on the web and by Compose Multiplatform to four targets, which makes the comparison concrete rather than theoretical.
  • Provider-agnostic chat backend (Groq / Gemini / Claude) with prompt-injection guards. Panda is grounded in this file — the same source of truth the pages render from, so the assistant cannot drift from the site.
React 19VercelLLM chatCompose MultiplatformWasm
DEADLOCK — in development, private repo with a public case study

DEADLOCK

In development · private repo, public case study ]

A first-person time-loop game about a moment someone could not let end.

Godot 4.7 in GDScript. A deterministic echo-replay spine — recorded input intent replays through the same physics step — powers cooperative echoes, ghosts, and boss desync from one system. Built solo as an AI-orchestrated dev crew.

  • One deterministic (state, InputFrame) → state step reused five ways: cooperative Echoes, ghosts, leaderboard replays, the Hunter, and boss desync.
  • A bit-exact determinism gate guards every change to the time systems, wired into a hook that reruns it automatically on every edit.
Godot 4.7GDScriptTime-loopSolo + AI dev crew
View case study →

The KMP toolkit family

Active · MIT · vendored across 5 repos ]

Three decoupled repos so a new app starts at "write the feature".

The reusable libraries, the shared build logic and the app shape each live in their own repo — vendored into five consumers via Gradle includeBuild, so a version bump happens once instead of per project.

  • kmp-toolkit: 36 modules, each extracted the moment a second consumer needed the same logic, never designed as a "platform" up front: typed Result, an MVI ViewModel core, an offline-first store, network, security, on-device AI behind one seam, device-integrity, an operation-log outbox, and a 19-provider payment-gateway abstraction.
  • kmp-build-logic — 17 convention plugins here (22 authored across all repos). The AGP / Kotlin / Compose / test / lint / Firebase / Room / Koin setup written once and applied with one line.
Kotlin Multiplatform36 modules22 convention pluginsMIT

The Loopdown

Active · public ]

Field notes from an engineer who writes: one war story, four channels, one branded card.

A dev-content engine and writing archive. A lesson pulled from a real project is written once and adapted to LinkedIn, dev.to, Hashnode and Medium, each with a generated branded graphic — plus the consolidated back catalogue.

  • One lesson in, four channel-shaped posts out, each with a branded SVG card. The adaptation is the product, not the writing.
  • A voice profile derived from the existing archive, enforced by a lint step, so the generated drafts do not read like a language model wrote them.
Node.jsContent engineOpen source

Shared foundation

Mileway and PaymentsLab aren't two isolated demos — they're two KMP apps sitting on a common foundation I built and maintain separately. Both pull in my own convention-plugin and MVI-base libraries as composite builds, so the build wiring and the unidirectional-state contract are written once and reused, exactly the platform discipline I bring to a codebase at scale.

↓ both libraries are in , one click from the code.

// the source

It's all public

Every app, the libraries they share, the tooling, and the upstream PRs — open, and one click away. The numbers are pulled from each repo, not typed by hand.

@darkpandawarrior

Merged upstream

career-ops · a public OSS project (⭐63k+)
all my PRs on career-ops

Recently shipped

Jul 2026

Mileway — super-profile & plugin platform (V24)

A plugin-composition registry (TILE/CAPABILITY/VALUE, FORCED>USER>PRESET>DEFAULT layering) driving four persona presets, plus delegation, verification, growth, membership and wallet/payout depth — shipped, with a V25→V37 series (on-device intelligence, JWT auth, closeout hardening, home cards/advances, What's New) landed on top.

Jul 2026

Shared KMP foundation

Extracted kmp-build-logic (convention plugins) and kmp-toolkit (MVI base) as my own libraries, consumed by Mileway and PaymentsLab as composite builds.

Jul 2026

PaymentsLab — 5 rails + 66 gateways

40-module KMP payments lab: payouts, mandates, card vault, marketplace Connect and a double-entry wallet ledger beyond one-shot pay-in — all MOCK_MODE-honest.

Jul 2026

Mileway — offline AI + policy engine

Retrieval-grounded chat over local data with voice I/O, a reimbursement-rate policy engine and a durable submit-outbox — still zero backend.

// on the store

Apps you can install

Shipped Android work, live on Google Play. Every rating and install count below was read from the listing itself, not quoted.

…and 170 more, under other people’s names

The Jugnoo rider and driver apps were a white-label platform: every client got its own build of the same codebase, its own branding, and its own listing on Play under its own company. I worked on it for two and a half years and never had a list of what came out of it — so I put one together, and kept only the apps the store itself shows were still shipping while I was there or after.

173
apps reached the store
47
companies published them
≥ 2.9M
installs across the live ones
See all 173, and how the list was rebuilt

// background

Experience

Consulting Engineer, Platform & AI @ Neev Consulting

April 2026 - Present
  • Agentic ERP: Built the LLM assistant layer of an ERPNext/Frappe consulting ERP: business-context resolution, capability discovery, and an AI capability gate that defaults OFF with a test proving it. Models client to project to PO to milestone to GST invoice to payment end to end.
  • Platform: Shipped the platform on Python and Frappe over MariaDB under Docker Compose, with a LibreChat deployment and MCP tool wiring for Atlassian and Playwright. Four repositories, all of it reviewed.

SDE-2, Android & Product Owner @ Dice.tech

June 2023 - Present
  • Platform Ownership: Own the Android platform end to end, a ~964k-LOC Kotlin app serving 50,000+ MAU, as both technical owner and Product Owner. Set the module architecture, release process and review standards the team builds against.
  • Scope: Owned requirements as well as delivery on the same platform. Here they are one job, not a handoff. Sprint planning, feature and code allocation across the team, review, release, deployment, and the crash dashboard the morning after. The platform work is deliberately the kind other people build on: a new client ships without anyone writing UI code, nobody forks the app to brand it, and every release goes out through the pipeline.
  • Team: Led interview loops and helped hire onto both the frontend and the React Native mobile teams; mentored a junior engineer from Flutter to production Kotlin, Java and React.
  • Mentorship Outcome: That engineer now manages this app at the company that acquired it.
receipts
+ 9 more
  • Compose Migration: Led the migration off legacy Java and XML: ~87% of the UI layer is now Compose, migrated incrementally through interop with per-screen parity checks against the legacy XML baseline.
  • Location Engineering: Own the GPS pipeline behind a location-type foreground service for 22,000+ DAU: staged dead reckoning over GPS/IMU with a 1D Kalman smoother and spike rejection so implausible jumps never reach the buffer, taking tracking accuracy from 50% to 95%.
  • Crash Reduction: Reduced production crashes 80% at 22,000+ daily users — the fix was the concurrency and threading model, not defensive try/catch, with Crashlytics and Sentry catching regressions before users report them.
  • Security Hardening: Hardened the app to VAPT/banking compliance: AES-256 Android Keystore field-level encryption, a biometric access gate, and SSL pinning across 9 domains (5 SHA-256 pins) via build flavors.
  • Data Layer: Own the Room persistence layer across two databases with 24 verified production schema migrations.
  • Product Growth: Built the in-app review prompting that moved the Play Store listing from 1.6★ across 67 reviews to 4.5★ across 27,300, the rating a prospective customer sees before they install anything.
  • Travel Platform: Shipped the Android side of Trip V2: Itinerary V2, GIN screens, and full Mixpanel instrumentation.
  • UI Platform: Built the multi-tenant theme platform: a server-supplied tenant seed colour resolves into a full Material 3 scheme at runtime (MaterialKolor), with the client owning dark mode, user colour override, palette style, Material You and variant, cutting UI development friction 60% without touching feature code per client.
  • CI/CD & Automation: Own the build platform: automated Fastlane build, signing and release pipelines, and drove the AGP 9 upgrade across the whole app, and wired agent tooling into the build itself (Firebender over MCP).

Software Engineer, Android & Vertical Owner @ Jugnoo / Tookan / Jungleworks

January 2021 - May 2023
  • Multi-Tenant Platform Ownership: Owned Android across a multi-vertical super-app (ride-hailing, carpool, delivery, grocery, bike and car rental, shuttle and wallet) spanning customer, driver and merchant apps. Joined a nine-year-old codebase seven years in, and became one of its primary maintainers.
  • White-Label Platform, Productising Variation: Built a per-tenant flavour system (build config, resource overlays, isolated storage and branding) so 150+ clients ship from one codebase across the customer and driver apps, rather than a fork per client. Cut per-client delivery time 80%.
  • Product-Line Ownership: Owned both the requirements and the implementation for the P2P carpool, trucking, e-bike and super-app verticals, writing the specs I then had to build.
  • Payments at Scale: Implemented Razorpay, Stripe, Beyonic and HyperPay gateway integrations across checkout flows; built Stripe 3DS payment retry/recovery handling and a corporate-account KYC verification flow from scratch.
+ 2 more
  • Platform Modernization: Migrated the toolchain across a multi-branch, multi-client codebase: Kotlin plugin and Gradle 7.0 migrations, ViewBinding adoption, and Android 13 (API 33) compliance, without breaking any of the 150+ client builds riding on it.
  • Cross-Functional Engineering: Collaborated cross-team on roadmaps with product and backend, cutting engineering overhead 40%.

GET Intern @ John Deere India

May 2020 - July 2020
  • Built a proof of concept integrating social-media sentiment analysis into financial lending systems to enhance credit-risk modeling.

B.Tech, Computer Science & Engineering @ NIT Bhopal (MANIT)

2017 - 2021

// not a PDF with a pulse

This site is a live demo

A running program, not a slide deck: Eight interactive rooms, each a small proof of the engineering above — plus 18,827 rated and casual chess games, mined and analysed at build time. The chess finding was not flattering: 41.7% of my decided games ended on a clock, not on a board.

Proof

the numbers, and what verifies them

Things that run

real programs, in the page

Corpus

long records, read as evidence

Writing

before the code, and alongside it

// before the code

The Ink

Before the Android work there were three years of a college magazine and a literary society — English Editor, then Joint Chief Editor of a 128-page edition shipped entirely remotely. Four published stories, all readable here, and the pieces the board wrote about me. It's a different life, so it gets a different room.

// tech stack

Skills

Filter by area, spin the orbit, or just hover the cloud.

Jetpack Compose + Material 3MVVM + Clean ArchitectureMVI / single UiStateModular architectureRepository patternKotlin/Compose MultiplatformDynamic theme enginesKotlin CoroutinesFlow / StateFlow / SharedFlowRoom (SQLite, 24 migrations · 2 DBs)DataStore + WorkManagerRetrofit + OkHttp (REST APIs)Android SDKLocation engineering (dead reckoning + Kalman)Foreground servicesHilt / Dagger (dependency injection)Firebase Crashlytics + Sentry + MixpanelCross-functional collaborationMentoring & hiring loopsCode review standardsAgile sprint planningAndroid Keystore field-level encryption (AES-256)SSL pinning (9 domains, 5 SHA-256 pins)BiometricPrompt access gateEncryptedSharedPreferences / DataStore + TinkFastlane CI/CD · AGP 9 · Gradle KTS · GitAgentic workflows (Firebender, MCP)
Open to remote (worldwide / India) and hybrid in Pune / Bengaluru

Hiring for a senior Android role?

Ask my AI assistant anything about my work, or reach out directly — I reply fast.

Let's talk

siddharthpandalai990@gmail.com