Guide · the whole path, priced and honest

    How to build an Android app in 2026: the complete guide

    Android is where most of the world’s users are — and, oddly, where most build guides stop trying: they explain iPhone development and add “also works for Android” at the end. This is the Android-first version: seven steps from idea to the Play Store, the Google-specific ceremony nobody warns you about, and the 2026 fact that changed the middle of the journey — real native Kotlin no longer requires a Kotlin developer.

    The map before the steps. Building an Android app has three phases with completely different bottlenecks: deciding (what to build, for whom — bottleneck: honesty), building (bottleneck: used to be Kotlin skills or money; in 2026 it is iteration count), and shipping (bottleneck: Google's ceremony, which runs on its own clock). The classic first-timer mistake is spending all anxiety on phase two — the one that got easy — and discovering phase three's paperwork at the worst moment. So we'll do them in order, and start Google's clock early.

    Steps 1–3: decide before you build

    Step 1 — make sure it's an app, and make sure it's Android-first. If users reach your product by link, build a website. If they install it, keep going — and settle the platform order deliberately: iOS or Android first is a ten-minute framework, and "Android because that's where my actual users are" is a fine answer that two-thirds of the world agrees with. No idea yet, or a fuzzy one? Ideas come from seven places, none of them the shower.

    Step 2 — write the one-pager. What the app does in a paragraph; three "user does X, sees Y" scenarios; what v1 deliberately excludes; the seven security lines if you store personal data. This page is the difference between directing the build and gambling on it — the spec-first argument in miniature.

    Step 3 — validate the cheapest way you can. Before real building: put the idea in front of strangers as a landing page, a clickable mock, or a one-evening prototype, and believe behaviour over politeness. An unvalidated app on the Play Store is just validation with extra steps and a $25 fee.

    Step 4: build it — the part 2026 changed

    The honest 2026 menu for actually producing the app, priced from vendors' own pages:

    Describe it, get native Kotlin. The route that didn't exist two years ago: you write plain language, an AI agent writes Kotlin with Jetpack Compose — Google's own stack — compiles it, and fixes its own errors. Modaal (ours) is built for this: PRD first, a reviewable spec per feature, then native code on your own disk; free plan with one project and unlimited prompts, Mac required. If iPhone is also in your future, the Duet architecture builds both native apps from the same project. The wider field for this route — including what is not actually native — is mapped honestly in the Android tools list.

    Describe it, get React Native. Rork Pro ($20/month, 100 credits) produces cross-platform JavaScript apps that run on Android — a real option when a JS team will inherit the code.

    Assemble it visually. FlutterFlow builds Flutter apps in a drag-and-drop editor; shipping and code download start at Basic, $39/month. Choose it for Flutter, not for the free tier.

    Learn Kotlin. Android Studio is free and Google's documentation is excellent — the right route if the goal is a career, the wrong one if the goal is this app this quarter.

    Whichever route: build ugly, put it on a real phone in week one, and iterate against actual thumbs. Iteration is where apps get good, which is why the meter question (credits versus unlimited) is a quality question disguised as a pricing one.

    Steps 5–7: the Google ceremony, started early

    Step 5 — register the day you commit, not the day you finish. A Google Play Console developer account costs $25, once — the cheapest store ticket in tech — but registration comes with identity verification, and Google has introduced pre-production testing requirements for new personal accounts before an app can go live. The specifics have changed more than once, so read Play Console's current rules the day you register — and plan for a testing phase either way, because it's genuinely useful (next step). Starting this paperwork in parallel with building is the single best schedule decision in this guide.

    Step 6 — test through the tracks. Play Console's testing tracks — internal, then closed — put your app on real phones via a simple link, long before public release. Use them the way TestFlight gets used on iOS: friends and early users on the closed track, a week of honest feedback, the embarrassing bugs found while they're private. If your account requires a testing phase anyway (step 5), this is that requirement turned into an asset.

    Step 7 — release, then behave like a shipped product. Production release goes through Google's review — days-scale, at their pace, no promises anyone can honestly make. Then the real work: read reviews, fix the top complaint, ship the update — and enjoy the part where the describe-review-build loop makes version 1.1 an afternoon instead of a quarter. Android GA on our side means both halves of the market are now open to this loop. {/ [GA-GATE] — cut this last sentence if GA has not happened at ship time /}

    The whole path on one screen

    StepWhat happensCostWatch out for
    1. DecideApp vs website; Android-first on purpose$0Building for a link-shaped product
    2. SpecOne page: scenarios, exclusions, security lines$0Skipping it and paying in rework
    3. ValidateStrangers + cheapest testable version$0Believing politeness
    4. BuildNative Kotlin via agent · RN via Rork $20/mo · FlutterFlow from $39/mo · learn Kotlin freeFree (Modaal, 1 project) and upCredit meters during debugging
    5. RegisterPlay Console account + verification$25 onceNew-account testing rules — read them day one
    6. TestInternal → closed tracks, real phones$0Skipping straight to production
    7. ReleaseGoogle review, then iterate$0Treating launch as the finish line

    Prices from vendors’ own pages (27 Aug–3 Sep 2026) and Google’s published fee. Google’s new-account testing requirements change — Play Console’s current rules are the source of truth.

    Frequently asked questions

    In 2026 the realistic route is describing it: an AI agent writes real Kotlin with Jetpack Compose — Google’s own stack — while you review plans in plain language. Modaal does exactly this (free plan, one project, unlimited prompts; ours, disclosed). Visual builders like FlutterFlow are the alternative if you prefer assembling screens to describing them — with a real learning curve and shipping from $39/month.

    The unavoidable cost is Google Play’s one-time $25 developer fee. Tool costs range from free (Modaal’s one-project plan; Android Studio if you code) through $20–39/month (Rork Pro, FlutterFlow Basic). The wildcard is iteration: credit-metered tools charge per attempt, which is why the pricing model matters more than the sticker.

    The build itself collapsed — prompt-based routes produce a working app in the first sessions, and the calendar is set by your iteration count. The fixed part is Google’s ceremony: account verification, testing requirements for new personal accounts (check Play Console’s current rules), and production review at Google’s pace. Start the paperwork on day one and build in parallel.

    Plan for it. Google has introduced pre-production testing requirements for new personal developer accounts, and the specifics have changed more than once — Play Console’s current rules are the source of truth. Treat it as a feature: the closed testing track puts your app on real users’ phones early, which is exactly what a first version needs anyway.

    Yes — the native version of that promise is a shared-core architecture: Modaal’s Duet builds one project into real Kotlin/Compose on Android and real SwiftUI on iOS, with the shared logic enforced to behave identically. Start Android-first on the free plan; Pro (€9/month billed annually) turns on the second platform when your users ask for it.

    Start free. Ship native.

    One project, unlimited prompts. No card.

    Download for MacThe Android tools, compared

    Keep reading