I build fast, native, and delightful Android apps. I'm an independent Android consultant with 3+ years of experience delivering high-performance production apps.
// Monochrome by design
data class Developer(
val name: String = "Akhand Pratap Singh",
val role: String = "Android App Developer",
val location: String = "Lucknow, IN",
val yearsOfExp: Double = 3.5,
val stack: List<String> = listOf(
"Kotlin", "Compose",
"Coroutines", "Hilt",
"Room", "Retrofit"
),
val available: Boolean = true
)
// psst — scroll to explore ↓Over three years of building Android apps end-to-end — from architecture to release, with a relentless eye on performance and craft.
I turn ideas into polished Android apps. From the first line of Kotlin to a release on the Play Store, I own the full lifecycle — architecture, UI, performance, testing, and rollout. Operating as an independent contractor, I've partnered with international clients, startups, and enterprise product teams to build everything from real-time chat apps to fintech platforms. My toolkit is modern Android: Compose, Coroutines, Hilt, Room, and a healthy obsession with metrics.
I treat performance as a feature. Every release ships with a baseline profile, a macrobenchmark gate, and a crash-free target above 99.5%. I believe great Android apps feel instant — and that's a deliberate engineering choice, not luck.
When I'm not shipping, I write about Compose and performance on my blog, contribute to open-source libraries, and mentor junior devs through architecture reviews.
Began contract engineering as a freelance developer. Standardized offline-first apps with MVVM, Room DB, Retrofit, custom OkHttp interceptors, and a clean repository layer, successfully shipping 12 commercial MVP products to Google Play.
Contracted for Pixel Labs client applications. Drove the migration of WalletPro and StreamFlow apps from legacy XML layouts to 100% Jetpack Compose with custom design systems, state hoisting, and comprehensive Compose UI test suites.
Partnered with Nimbus Tech as a senior consultant. Formalized Clean Architecture boundaries, modularized Gradle builds, and established strict Jetpack Macrobenchmarks and Baseline Profile CI/CD pipelines, cutting cold-start latency by 28%.
Leading edge AI integrations with Gemini Nano (AICore) and local vector embeddings. Architecting cross-platform Kotlin Multiplatform (KMP) shared modules using Ktor and SQLDelight. Consulting clients on modern APIs.
Began contract engineering as a freelance developer. Standardized offline-first apps with MVVM, Room DB, Retrofit, custom OkHttp interceptors, and a clean repository layer, successfully shipping 12 commercial MVP products to Google Play.
Contracted for Pixel Labs client applications. Drove the migration of WalletPro and StreamFlow apps from legacy XML layouts to 100% Jetpack Compose with custom design systems, state hoisting, and comprehensive Compose UI test suites.
Partnered with Nimbus Tech as a senior consultant. Formalized Clean Architecture boundaries, modularized Gradle builds, and established strict Jetpack Macrobenchmarks and Baseline Profile CI/CD pipelines, cutting cold-start latency by 28%.
Leading edge AI integrations with Gemini Nano (AICore) and local vector embeddings. Architecting cross-platform Kotlin Multiplatform (KMP) shared modules using Ktor and SQLDelight. Consulting clients on modern APIs.
Performance is a feature. Here's the measurable impact across the apps I've shipped — every metric verified by a benchmark, not a gut feeling.
Average cold-start reduction across 3 apps after Baseline Profiles + Macrobenchmark gates.
Crash-free session rate achieved after migrating client codebases to Jetpack Compose.
Clean build time of modularized Gradle builds after layer-first design + version catalogs.
StreamFlow buffering reduction after predictive pre-fetch + ABR tuning on contract assignment.
FitTrack per-workout battery drain reduction via sensor batching + WorkManager integration.
Compose UI test coverage achieved after designing shared test harnesses for startup clients.
Every metric above is gated by a CI benchmark. If a regression slips in, the build fails.
From the first line of Kotlin to a Play Store rollout — here's what I reach for, organized by what it solves.
The languages I write every day.
Modern, declarative Android UI.
Patterns that scale with teams.
Concurrency, persistence, networking.
Build pipelines and dependency injection.
Keeping things at 60/120fps.
Confidence before ship.
Cloud LLMs, agentic workflows, and RAG systems.
Edge computing, on-device models, and computer vision.
Android 15+ modern OS capabilities.
Low-level system and native capabilities.
Peripherals, sensors, and hardware APIs.
When one codebase makes sense.
Daily drivers.
Self-assessed proficiency across the core Android stack — measured in years of production use, not tutorials watched.
A sample of what I've built recently — filter by category, click any card for the full case study.
FeaturedMedia DetailsHigh-fidelity audio enhancer (Solo)
An advanced audio equalizer and bass booster app utilizing low-latency Android audio session routing and custom band equalization. Currently in closed testing on the Play Store, preparing for public release.
FeaturedProductivity DetailsPhysical keyboard exam preparation (Solo)
A specialized training application helping candidates prepare for government typing exams with physical keyboard integration and real-time WPM metrics. Shipped as a solo project directly to the Play Store.
Productivity DetailsMarkdown and rich text compiler (Solo)
A clean, local-first document editor supporting rich-text compiling, markdown syntax parsing, and batch file exporting. Shipped as a solo project directly to the Play Store.
Consumer DetailsOn-device AI assistant (Team)
Collaborated with a cross-functional team of 4 to design and optimize an on-device generative AI assistant utilizing Gemini Nano (AICore) and LangChain4j.
Fintech DetailsUnified payments platform (Team)
Worked in a cross-functional team of 6 engineers to scale a banking-grade fintech app handling millions of transactions with zero critical security vulnerabilities.
Media DetailsAdaptive video multiplatform client (Team)
Collaborated on a Kotlin Multiplatform (KMP) video streaming app with a shared business logic module (Ktor, SQLDelight) and dynamic Jetpack Compose UI.
Fintech DetailsBanking-grade finance app (Team)
Collaborated in a team of 3 developers at Pixel Labs to build a secure personal finance application featuring biometric auth, SQLCipher local vault, and instant payment interfaces.
Media DetailsAdaptive video streaming client (Team)
Worked in a team of 4 to construct a high-performance streaming app featuring predictive buffering, adaptive bitrate rendering, and custom player overlays.
Health DetailsOffline-first fitness companion (Team)
Collaborated with 3 developers at DevStudio to construct an offline-first fitness app with sensor-driven activity recognition and scheduled syncing.
A rotating set of snippets that show how I actually write Android — Compose, Flow, Hilt, benchmarks, Gradle. Click through, copy what's useful.
The Compose mental model in one screen: state flows down, events flow up. No findViewById, no lifecycle leaks.
@Composablefun ProfileCard( name: String, role: String, modifier: Modifier = Modifier,) { var expanded by remember { mutableStateOf(false) } Column(modifier.padding(16.dp)) { Text(name, style = MaterialTheme.typography.titleLarge) Text(role, style = MaterialTheme.typography.bodyMedium) AnimatedVisibility(expanded) { Text("3+ years shipping Android apps.") } TextButton(onClick = { expanded = !expanded }) { Text(if (expanded) "Show less" else "Show more") } }}A repeatable, four-phase rhythm that de-risks delivery and keeps you in the loop the whole way.
I dig into the problem before writing a line of code. We align on goals, users, constraints, and what success actually looks like.
I translate requirements into an architecture and a UI direction. You see clickable prototypes and an architecture diagram before any production code.
This is where the app takes shape. I ship in vertical slices — each one demoable, tested, and behind a feature flag.
Launch is just the beginning. I set up phased rollouts, crash monitoring, and a feedback loop so the app keeps getting better after release.
Every phase ends with a demoable artifact. No “trust me, it's coming” — you see progress weekly.
A live snapshot of what's on my desk — inspired by /now pages. Updated July 2026.
A Compose Multiplatform side project — shared logic between Android & iOS.
Diving into K2 compiler internals and the new Compose compiler metrics.
“Android Performance: Scheduling” by Chet Haase — again, for the third time.
A blog series on Baseline Profiles that actually move the needle.
Where I've shipped, what I owned, and the impact it made.
Provide expert consultancy and custom native engineering for scale-ups and enterprise clients. Specializing in low-latency GenAI optimizations, modular architecture overhauls, and Kotlin Multiplatform integration.
Contracted with early-stage startups and product design studios to construct robust MVPs, media streaming clients, and secure finance tools.
Built, optimized, and published custom Android products and client MVPs, managing the entire lifecycle from early layout design to Play Store distribution.
Hard-won lessons on Android performance, Compose, and architecture. No fluff — just what moved the needle.
Integrating Gemini Nano on-device via AICore can be challenging. Here is how we achieved sub-85ms response times while reducing RAM consumption by 40%.
Sharing video playback logic between Android and iOS without sacrificing native performance. Here is how we engineered the VibeStream player wrappers.
Most teams add a Baseline Profile and call it done. Here's how to measure the real impact — and the three mistakes that silently kill your gains.
LazyColumn is fast by default, but the moment you add async images, nested scrolling, or heavy item composition, the frame drops creep in. Here's my debugging playbook.
The things I get asked most. If your question isn't here, just drop me a message — I reply within 24 hours.
Four ways I partner with teams and founders — from a single audit to owning an app end-to-end.
High-performance, greenfield apps built with Kotlin & Jetpack Compose, complete with offline-first synchronization and Gemini Nano AI integrations.
Safely refactor legacy Java/XML codebases into modular, modern Kotlin projects without losing feature parity or introducing regressions.
Diagnose, measure, and resolve playback lag, slow cold-starts, memory leaks, and render-jank to dramatically improve Google Play vitals.
Build modular internal SDKs, payment gateways, and custom media wrappers that simplify collaboration and integrate smoothly with third-party systems.
A few words from the people I've worked with across three years of Android development.
“Akhand rewrote our app in Compose and our crash-free rate went from 97% to 99.8%. He thinks in systems, not screens.”
I reply to every serious enquiry within 24 hours. Tell me what you're building and I'll get back with thoughts.
Prefer a direct line? Use any of these — or drop a message in the form.
Available for freelance contracts & consulting
My daily setup — the hardware, software, and Android-specific tools I reach for every day. Inspired by /uses pages.
Daily driver on Windows. Bounded heap bumped to 8GB; previews rendered on a secondary 4K display.
For quick edits, config files, and markdown. Running in Windows Terminal with LazyVim and custom LSP mappings.
Configured with Oh-My-Posh prompts, GPU-accelerated rendering, and custom Gradle aliases.
For running background node scripts, shell scripts, and Docker containers without Windows path overhead.
Keeps Android Studio Stable + Canary builds organized and up to date.
12 cores / 24 threads, 64GB DDR5 RAM. Compiles our modular KMP projects in under 50s.
Main display. Compose preview on the left, code editor on the right.
Brown switches. Quiet enough for client calls, tactile enough for deep flow states.
Noise cancelling for deep focus during remote contract sprints.
Physical test devices. Essential for checking OEM battery constraints and on-device GenAI models.
Issue tracking. The keyboard-first workflow is unbeatable.
Design handoff. I inspect, don't design — but I can read a spec.
Source control + CI. Every PR runs Macrobenchmarks.
Open-source, Git-friendly API client used to verify API payload contracts and interceptors.
Architecture docs, client deliverables, meeting notes, and workspace planning.
Mirror physical devices to Windows desktop — lag-free and wireless.
Network debugging. Essential for tracking interceptors and payloads.
For capturing system-level traces to profile frame drop rate, startup time, and lock contention.
Always on in debug builds. Catches memory leaks before shipping to production.
With recomposition tracking enabled — my #1 Compose debugging helper.
This setup evolves. Last updated July 2026.
Signed by colleagues, clients, and readers. Say hello, share a thought, or drop a recommendation.
Akhand shipped our UPI module in 3 weeks. The code was so clean our junior devs could extend it without a single question.
The rare dev who pushes back on scope creep with data. Our app shipped smaller, faster, and better because of it.
Read your Baseline Profiles article, applied it to our app, cold start dropped 22%. Genuinely useful writing.
Search for a command to run...