Kotlin,FlutterorReactNative:WhattoBuildYourAndroidAppWith

Android runs on about 72% of the world's smartphones. But the question of what to build an Android app with comes down to three fundamentally different paths: native Kotlin, cross-platform Flutter or React Native. Each has its own cost, timeline and limitations. The choice isn't obvious, and the price tag ranges from $9,900 to about $115K.

This article is an honest comparison of the three approaches with concrete numbers: cost, speed, performance, and when to pick which. No marketing fluff, just the facts a CEO or CTO needs.

The three approaches at a glance

Kotlin (native development)

Google's official language for Android. The code compiles to native, so you get maximum performance and full access to every device API. One downside: the app runs only on Android. For iOS you need a separate build in Swift.

Flutter (cross-platform, by Google)

One Dart codebase produces apps for Android and iOS at the same time. Flutter has its own rendering engine (Skia/Impeller): it doesn't use native components and draws everything itself. The result is the same UI on both platforms with 90%+ shared code. The downsides: a larger app size, and platform-specific native features need "bridges".

React Native (cross-platform, by Meta)

One JavaScript/TypeScript codebase for Android and iOS. It uses native UI components through bridges (the New Architecture uses JSI). The upside: a huge ecosystem of JS developers. The downside: performance is lower than Flutter and Kotlin, especially in animations.

Comparison: development cost

This is the parameter that matters most to a business. We'll use a typical mid-size app as the example: sign-in, profile, catalog, orders, push notifications, payments.

The key math: if you need both platforms (Android + iOS), cross-platform saves 30–40% of the budget. Separate Kotlin and Swift apps cost 1.7–2x as much as one Flutter app. If you need ONLY Android, Kotlin is 20–30% cheaper.

Comparison: performance

Performance isn't an abstract metric. Here's where it actually matters.

Animations and UI

Kotlin: a steady 60 fps. Native components optimized by Google. The best option for apps with a heavy UI (3D, complex animations, AR).

Flutter: 60 fps in 95% of scenarios. Its Impeller renderer is very fast, comparable to native. Complex animations run at 90% of native performance.

React Native: 60 fps for a simple UI. Complex animations with the New Architecture (JSI) reach 80–90% of native. Without the New Architecture, you'll see noticeable lag on mid-range devices.

App startup

Kotlin: cold start in 0.3–0.8 s. The best result.

Flutter: cold start in 0.5–1.2 s. Slightly slower because the Dart VM has to initialize.

React Native: cold start in 0.8–2 s. The JS bundle takes longer to load. Hermes (Meta's JS engine) makes it faster, but it's still slower than Flutter.

Hardware access

Kotlin: full access to the camera, Bluetooth, NFC, GPS and sensors. No restrictions.

Flutter: access through plugins. Ready-made plugins cover 95% of features. For unusual cases (BLE profiles, custom NFC commands) you need native bridges written in Kotlin, which adds $1,000–2,700.

React Native: access through native modules. The library ecosystem is large, but quality is uneven. For Bluetooth and NFC you often end up writing native code.

Comparison: development speed

Flutter: the fastest option for cross-platform development. Hot Reload (instant UI refresh), declarative UI built from widgets, one codebase for both platforms. Typical savings: 30–40% of the time compared with building two native apps.

React Native: comparable to Flutter in speed. The advantage: if your web team already knows React, the switch to React Native is faster. Hot Reload, a component-based approach. But native modules slow development down.

Kotlin: slower for a cross-platform job, since you need a separate iOS build. But faster if you only need Android: there's no overhead from cross-platform abstractions, and the native tools (Android Studio, Jetpack Compose) are built specifically for Android.

When to choose Kotlin

When to choose Flutter

When to choose React Native

Cost by app type

Concrete numbers for typical projects (Android + iOS, Flutter):

For more on mobile development costs, see our article on how much a mobile app costs.

How to publish on Google Play

A quick checklist for first-time publishers:

Developer account: $25 (one-time). Verification takes 1–2 days.

Google Play requirements: a target API level (at least API 34, Android 14; Google raises the bar every year, so check the current minimum before release), a privacy policy (mandatory), the Data safety form (what data you collect), a content rating (the IARC questionnaire), graphics and screenshots (at least 4 screenshots and a 1024x500 feature graphic).

Review: 1–7 days (longer the first time). Common reasons for rejection: no privacy policy, undeclared permissions, content that violates the policies, crashes on review devices.

ASO (App Store Optimization): a title of up to 30 characters (with keywords), a short description of up to 80 characters and a full description of up to 4,000 characters. All of this affects your ranking in Google Play search.

Our approach: Android from $9,900

At March Code we build Android apps mostly in Flutter, because in 80% of projects the client needs both platforms and Flutter offers the best balance of cost and performance. For projects that need native development (BLE, AR, heavy graphics), we use Kotlin.

The process: 1) analysis and prototype (1–2 weeks), 2) UI/UX design (2–3 weeks), 3) development (4–12 weeks), 4) testing and publishing (1–2 weeks). More details on our mobile development page.

FAQ

Is Kotlin Multiplatform an alternative to Flutter?

Partly. KMP lets you share business logic (network requests, data models) between Android and iOS, but the UI is usually written natively for each platform (Compose and SwiftUI). Savings: 20–30%, versus 30–40% with Flutter. The plus: a native UI on each platform. The minus: you need developers who know both Kotlin and Swift. KMP is a good choice when you want the most native experience possible and the team knows both languages.

Can we update the design without rewriting the code?

Yes, if the architecture is right (UI separated from business logic). In Flutter or Kotlin with a sound architecture (MVVM, BLoC), a UI redesign costs 30–40% of the original budget, because all the business logic stays as it is.

How much does Android app support cost?

Minimum: $700–1,300/month (backend hosting, monitoring, small fixes). Typical: $1,700–$2,900/month (plus updates for new Android versions and new features). Mandatory: a yearly target API level update (a Google Play requirement); otherwise Google Play stops offering the app to new users.

Does an Android app need a backend?

In 95% of cases, yes. An app without a backend is a calculator or a notepad. Sign-in, data storage, push notifications and payments all need a server. Backend cost: 30–50% of the app's cost. We use Node.js/Next.js + PostgreSQL.

Which is better for a startup, Flutter or React Native?

Flutter. Better performance, a more stable ecosystem, faster Hot Reload. Choose React Native only if 1) your team already writes React, 2) you need to share code with a web app, or 3) you need over-the-air updates.

Can we release an Android app without an iOS version?

Yes. It makes sense if your audience is mostly on Android (for example, a fleet of couriers, drivers or field technicians where 90%+ of devices run Android), if it's an internal company app (you buy devices for one platform), or if the budget is tight (Kotlin-only is 20–30% cheaper). But keep in mind that about 28% of smartphones worldwide run iOS (in the US, more than half), and iOS users are the audience that spends more.