Behind every mobile app that just works is a layer nobody sees. I build that layer.

Hi, I'm Imran, a mobile engineer with deep Android roots. I do my best work where one well-built layer lifts every team above it, starting with a modular architecture built on clear boundaries and contracts, so any part can change without breaking the rest. I also build a Kotlin Multiplatform core that iOS reuses, the harness that keeps AI-written code honest, and the foundations that keep apps fast, secure and stable.

KotlinCoroutines & FlowJetpack ComposeKotlin MultiplatformSwiftSPM + SKIELiteRTOn-device ML
Gradle modulesAndroid LintWorkManagerAndroid KeystoreGitHub ActionsJenkinsAzure DevOpsAI coding agents

Android app modernization

Untangle the monolith. Let every team ship in parallel.

I modernize production Android apps end to end and build the foundations they run on. Two principles shape every decision: separation of concerns, so each module has one job and one reason to change, and dependency inversion, so features depend on contracts rather than implementations. Together they let any piece be replaced, tested or owned on its own without touching the rest.

  • Teams ship in parallel
  • Cold start cut by 31%
  • 99.99% crash-free users
:app
depends on ↓
:feature-home-*uidomaindata
:feature-search-*uidomaindata
:feature-profile-*uidomaindata
depends on ↓
:core-analytics
:core-network
:core-config
Illustration. Module names are examples.

01

Boundaries the compiler enforces

Each feature ships as data, domain and UI modules owned by one team, so ownership, build caching and test scope all follow the module graph. Cross-cutting capabilities sit in core modules behind narrow interfaces.

02

Depend on contracts, not implementations

Domain owns the interfaces; data and core supply the implementations, bound at the app edge. When one feature needs another, it depends on that feature's domain module, never its data or UI. Implementations change freely behind the contract, so the blast radius of a change stays local and every layer stays testable on its own.

03

Migrate without a freeze

Once business rules leave the screens, the UI moves to Jetpack Compose screen by screen on shared design-system components, while feature work keeps shipping. Recurring crashes and ANRs get fixed at the root along the way.

04

Make the architecture self-enforcing

Dependency rules, lint and build checks run on every change, for engineers and AI assistants alike. The design holds without anyone policing it in review, so teams can keep scaling in parallel.

Read: Breaking an Android monolith: the order that works →

Kotlin Multiplatform

Write the logic once. Ship it natively on Android and iOS.

I build Kotlin Multiplatform frameworks that bring code sharing to a product's Android and iOS apps, including mature apps that have always shipped separately. The UI stays native on each platform. The logic underneath is written once.

  • No duplicated code
  • Native performance
  • Easy integration on both apps
Android app
iOS app
Native UI
Native UI
Business rules
Business rules
Networking and models
Networking and models
Caching and storage
Caching and storage
Illustration. Layer names are examples.

iOS

Arrives as a Swift package

The shared core ships to iOS as a versioned XCFramework through Swift Package Manager, with SKIE bindings so the API reads like Swift.

Android

Plugged in as a submodule

The shared code is maintained in its own repository and plugged into the Android app as a git submodule, so engineers can step through it and change it alongside the app.

Adoption

Both teams build on it

The best sign it works: Android and iOS engineers add their own shared components without being asked.

Read: Kotlin Multiplatform in two established apps →

Engineering with AI

AI writes the code. The harness keeps it honest.

Any coding agent can write code that compiles. On a large mobile codebase, that code can still cross module boundaries, ignore the patterns the team agreed on and quietly pile up review work. I build the harness around the agent so its speed shows up as shipped features, not cleanup.

agent session · add filters to search

› reads AGENTS.md and the golden-path feature

› runs skill: create-feature-slice

› agent-verify.sh :feature-search

✓ compile, unit and architecture tests

✓ screenshots: light, dark, large font

about 20 seconds, ready for human review

Illustration of an agent working inside the harness.

01

Context it can read

A short file that explains how the codebase works, scoped notes for sensitive areas, and one clean feature to copy from, with the legacy code clearly marked.

02

Skills for repeated jobs

Packaged procedures for the work a team does again and again, like adding a feature module or moving a screen to Compose, so the result comes out the same every time.

03

A fast, visible loop

One command that checks only the module that changed, UI rendered to screenshots on the JVM, and narrow device tools, so the agent sees its own mistakes in seconds.

04

Rules in the build

Architecture rules the build enforces, with failure messages that tell the agent how to fix them, while decisions about boundaries, security and UX stay with people.

Read: An AI harness for mobile engineering →

01 · Product delivery

Feature development

I build the parts people actually touch, on consumer apps with tens of millions of installs. I can take a feature from the first design doc through build, a staged rollout and the dashboards after launch, and own it on Android while working closely with the iOS and backend teams it depends on.

The kinds of features I'm good at: screens that product can rearrange from the server without an app release, offline-first flows that let people finish a whole task with no signal and sync later, camera and on-device ML experiences that run in real time, and AI features launched on several platforms at once.

Read: Offline-first flows →
DesignBuildRoll outMonitor
  • Server-driven UIno app release
  • Offline-first flowsno signal needed
  • Camera and on-device MLreal time
  • AI featurescross-platform

02 · Quality

App stability

I treat stability as an engineering problem, not a bug queue. I start from impact: which crashes and ANRs reach the most people, on which devices and OS versions. Then I group them by root cause instead of by stack trace, because ten crashes that look different often come from one bad assumption.

The hard ones are the ANRs that never happen on my own phone. I work those from traces, breadcrumbs and production data rather than guesses, looking for the usual suspects: disk reads on the main thread, lock contention, slow binder calls and work started at the wrong point in the lifecycle. I can do this in any part of an app, from sign-in to the heaviest screens.

When I find the cause, I fix the whole class of bug, not just the one report, and add a lint rule or a test so it can't quietly come back. I ship releases in stages with crash and ANR rates watched at each step, so a regression stops at a small percentage of users instead of reaching all of them.

Read: App stability is an engineering problem →
how I work a stability problem
  1. 1Rank by user impact
  2. 2Group by root cause
  3. 3Reproduce from traces
  4. 4Fix the whole class
  5. 5Add a guard: lint or test
  6. 6Staged rollout, watch the rates
Every fix leaves a check behind.

03 · Reusable building blocks

SDKs and libraries other teams build on

I build the kind of code other apps depend on: embeddable SDKs, shared UI libraries and design systems that several apps or teams build on at once. I design them so people take only what they need, the public API stays small and stable, and an upgrade doesn't break anyone.

In practice that means splitting a large SDK into independent components, replacing heavy third-party dependencies where in-house code does the job better, making the UI themeable so one codebase can serve several products, and building accessibility in from the start instead of adding it at the end.

Read: Building SDKs other apps can depend on →
Before: one SDK, all or nothing
core · network · UI · camera · analytics
After: take only what you need
corenetworkUIcameraanalytics

04 · Security and compliance

Secure storage and hardening

I can harden an Android app to meet strict security and compliance requirements: encrypting personal data, keeping keys in secure hardware, and automatically blocking banned dependencies before they reach a build.

I design storage so keys stay in the Android Keystore's secure hardware and data is protected with envelope encryption. When a key is lost, say after a user changes their lock screen, the app recovers cleanly instead of crashing. And I put all the cryptography behind one interface in one module, so when an auditor asks how the app encrypts data, the answer is a package they can read in an afternoon.

Read: Hardening an Android app →
  • Android Keystore
  • Biometric-bound keys
  • PII encryption
  • Dependency blocking

05 · Automation

CI/CD pipelines

I design the CI/CD pipelines that build, test and release the apps, and run them on whatever a team already uses: GitHub Actions, Jenkins or Azure DevOps. That includes packaging a shared Kotlin core as an XCFramework for iOS.

The part I care about most is what they catch. Every pull request checks module boundaries, blocks banned dependencies and runs screenshot tests, and release builds ship with fresh Baseline Profiles so startup stays fast. A broken rule fails in CI within minutes instead of surfacing in review, which is what turns a release into a routine event instead of a project.

Read: Architecture guardrails for AI-written code →
pull request · checks

✓ build and unit tests

✓ architecture rules

✓ banned dependencies

✓ lint and screenshot tests

✓ package XCFramework

ready to release

06 · People

Leadership and mentoring

I can lead a team hands-on through a large rewrite: set the direction, take on the hardest parts myself, and bring engineers who are new to the stack up to speed along the way. I'm usually the person people come to when a problem is stuck.

I grow engineers with a staged plan: fundamentals, small fixes, module boundaries, then a feature they own end to end, with each step only as big as the person is ready for. It works as a reusable onboarding toolkit, so the next new hire starts from a plan instead of a blank page.

BasicsSmall fixesBoundariesEnd to end

The playbook

How I build mobile apps that last.

Thirteen plays from real codebases: what works, what breaks, the tradeoffs, and the order I'd do it in.

AI engineering Why platform engineering matters more when AI writes the code When code is cheap, the expensive part is everything it gets written inside: boundaries, shared cores, the build and the checks. Read AI engineering An AI harness for mobile engineering, from first principles Agents that do fine on a backend fall over on mobile, mostly because the feedback loop is slow and blind. How I get mine under 20 seconds. Read AI engineering Teaching an agent your codebase: context files and skills What goes in a 100-line AGENTS.md, what I leave out, and when a reusable skill beats a longer prompt. Read AI engineering Architecture guardrails for AI-written mobile code AI writes code faster than anyone can review it. So I stop leaning on review and make the build say no. Read App modernization Breaking an Android monolith: the order that works Separation of concerns and dependency inversion, in an order that keeps features shipping: core modules first, then data, domain and UI for each feature, connected only through domain contracts. Read Feature development Offline-first flows: letting users finish the job without a connection Save first, sync later, and make the sync safe to repeat. How I'd build an offline flow again. Read Kotlin & Architecture Structured concurrency and Kotlin Flow at scale The handful of rules I keep coming back to for coroutines and Flow in a modular Android and KMP codebase. Read Kotlin Multiplatform Kotlin Multiplatform in two established apps Sharing code between two mature apps is a people problem with a build system attached. What to share, how to ship it and what it costs. Read Reusable building blocks Building Android SDKs other apps can depend on A small public API, modules people can pick, careful dependencies and deprecations that don't break anyone. Read Performance Where Android startup time goes, and how to get it back Startup is the one number every user feels on every launch. How to measure it honestly and where the time hides. Read Quality App stability is an engineering problem, not a bug queue Rank by users affected, group by root cause, read the ANRs you can't reproduce, and leave a check behind every fix. Read Security Hardening an Android app: Keystore and beyond What the Keystore protects, what it does not, and the settings that close the holes people leave open. Read Case study Inside LiteRT: a case study in on-device pose tracking Taking pose tracking from MediaPipe to LiteRT in Google Play services: what the runtime really does, the glue I had to own, and 12.5 MB off the app. Read