# Building an Android App Entirely From a Phone: What Actually Works

I built and shipped a Python Android app to Google Play without ever opening a laptop. Not as a stunt — I simply didn't have a PC. Here's what that setup actually looks like, where it holds up, and where it falls apart.

## The stack that made it possible

Python was less a choice than the only realistic option. There is no Android Studio for Android, no Gradle you can comfortably drive from a touchscreen. But there *is* a working Python environment.

*   [**Pydroid 3**](https://play.google.com/store/apps/details?id=ru.iiec.pydroid3) — a full Python 3.13 interpreter with a usable editor. This is where code gets written and tested first.
    
*   **Kivy 2.3.0 + KivyMD 1.2.0** — the UI layer. Renders identically in Pydroid and in the final APK, which matters enormously when you can't debug on a desktop.
    
*   **GitHub Actions +** [**Buildozer**](https://buildozer.readthedocs.io/en/stable/) **\+ python-for-android** — the build pipeline. You cannot compile an APK on a phone. You push, CI builds, you download the artifact.
    
*   **SQLite** — local storage, no server involved.
    

The critical insight: development and build are separated. The phone writes code, GitHub compiles it. Once you accept that split, a lot becomes possible.

## What genuinely works better than expected

**Iteration in Pydroid is fast.** Faster than waiting on a Gradle sync, honestly. You edit, you run, you see the result. For UI work with Kivy this loop is tight.

**GitHub Actions is a complete substitute for a local build machine.** A push triggers Buildozer, which runs python-for-android with the sdl2 bootstrap and produces builds for `arm64-v8a` and `armeabi-v7a`. Twenty minutes later there's an APK waiting. You never touch a terminal.

**Copy-paste is a legitimate workflow.** Working with an AI assistant through a browser chat window, file by file, sounds primitive. It is primitive. It also works — the project reached 64+ files and roughly 26,600 lines this way. The constraint forces something useful: you have to actually understand the architecture, because nothing is auto-imported for you.

## Where it breaks

Being honest about this matters more than the success story.

**Native libraries are the hard wall.** When Android 15 introduced the 16 KB page size requirement, the fix lived inside python-for-android's native build layer. That is not something you resolve by pasting files into a chat window. That single problem required a proper agentic coding tool with terminal access — the one genuine exception in the whole project.

**p4a has constraints you must design around.** Three that cost me real time:

*   **SQLite ships without FTS5.** No `MATCH`, no `bm25()`. Full-text search has to be built on `LIKE` and manual fragmentation.
    
*   `requests` **must be imported inside methods**, not at module level, or the app can fail to start on some devices.
    
*   **File paths are restricted to** `getExternalFilesDir`**.** Writing to `/storage/emulated/0/` directly is blocked by Scoped Storage. Every path in the codebase has to respect this.
    

**Two environments, one codebase.** Code must run in both Pydroid (Python 3.13) and the packaged APK (Python 3.11 via p4a). Version differences surface in irritating places.

**Debugging a release build is painful.** No `adb logcat` on hand, no breakpoints. You log to a file, read the file on the device, and reason backwards.

## Practical advice if you try this

**Set up CI before you write real code.** If the pipeline isn't proven on day one, you'll discover packaging problems weeks later with hundreds of files already written.

**Keep files small and single-purpose.** When your entire code-transfer mechanism is copy-paste, a 2,000-line module is a genuine obstacle. Small modules are not a style preference here — they're a hard requirement.

**Write the constraints down and re-read them.** I keep a plain-text file listing every p4a limitation, path rule, and import quirk. It gets re-read constantly. Working without an IDE means the tooling won't catch mistakes for you.

**Test on the weakest device you own.** Kivy's performance ceiling is lower than native. Something smooth on a mid-range phone can stutter badly on an older one.

## Was it worth it?

The app is on [Google Play](https://play.google.com/store/apps/details?id=com.nova_hata.molfar). It passed a 14-day closed beta with 19 testers. It runs on Android 7.0 and up.

The interesting part isn't that it's *possible* — it's that the barrier turned out to be far lower than assumed. A phone, a free CI runner, and a browser tab cover most of it. Not comfortably, and not for every kind of project. But the assumption that you need a desktop to build and ship real software is worth questioning.

If your only machine is the one in your pocket, that isn't automatically a dead end.