Skip to content

Guide · Mobile apps

Mobile App Development Guide

Mobile apps live under constraints the web does not have: two store reviews, unreliable networks, limited battery and users who rarely update. This guide covers the platform, policy and offline decisions that shape a mobile product before design begins.

Platform choice tied to device features

Store policy checked before scoping

Offline behaviour designed per screen

Before you build

Decisions to make before you build a mobile app.

01Decide

Native, cross-platform or web first

Native Swift and Kotlin give the deepest device access and platform feel; React Native and Flutter share most code across iOS and Android; a progressive web app avoids stores entirely but has limited device access, especially on iOS.

02Decide

Which platform launches first

Look at your audience’s devices, not national averages. Some markets lean heavily towards Android, some customer segments towards iPhone. Launching one platform first halves testing while you learn.

03Decide

How you will charge

Digital goods and subscriptions used inside the app usually must go through the stores’ in-app purchase systems; physical goods and services consumed outside the app generally do not. This choice affects margins and design.

04Decide

What must work without a connection

Decide per screen whether content is cached, whether actions can be queued offline and how conflicts are resolved when the device reconnects.

05Decide

Which permissions you truly need

Location, camera, contacts, notifications and tracking each need a clear purpose. Stores ask you to justify them, and users decline requests that appear without explanation.

Structure

How a mobile app is structured.

01Layer

Presentation layer

Screens, navigation and components following platform conventions, with support for dynamic text sizes, dark mode, screen readers and different device sizes.

02Layer

Local data and sync layer

An on-device database or cache, a queue for actions taken offline, and sync logic that reconciles with the server and handles conflicts.

03Layer

Device services layer

Push notifications, location, camera, biometrics, payments and deep links, each wrapped so permissions and failures are handled consistently.

04Layer

API and backend

Versioned endpoints that tolerate old app versions still in use, authentication with refresh tokens and server-driven configuration for flags and copy.

05Layer

Release and monitoring layer

Build signing, store listings, staged rollouts, crash reporting, analytics and a forced-update mechanism for versions that must be retired.

Planning sequence

A planning sequence for a mobile app.

  1. 01Step 1

    Read the store policies for your category

    Before scoping, check the App Store Review Guidelines and Google Play policies for payments, user-generated content, health, finance or children’s data. Some rules change the product shape.

  2. 02Step 2

    Prototype the core flows on devices

    Test clickable prototypes on real phones, one-handed and outdoors. Small screens and interruptions expose problems a desktop mock hides.

  3. 03Step 3

    Decide the offline and sync rules

    Write down, per screen, what users see without a connection and what happens to actions they take. This shapes the data layer.

  4. 04Step 4

    Set up release plumbing early

    Developer accounts, signing, test tracks such as TestFlight and Play internal testing, crash reporting and analytics should exist before the first feature ships.

  5. 05Step 5

    Launch with a staged rollout

    Release to a small percentage of users, watch crash-free sessions and reviews, then widen. Keep a way to force upgrades from broken versions.

Mistakes

Mistakes that derail a mobile app.

01Avoid

Assuming everyone updates

Old app versions remain installed for a long time. Breaking an API without versioning leaves those users with a broken app and one-star reviews.

02Avoid

Asking for every permission on first launch

A wall of permission prompts before users see value leads to refusals that are hard to reverse. Ask in context, after explaining why.

03Avoid

Treating the network as reliable

Lifts, trains and rural areas drop connections. Screens that spin forever or lose a half-completed form drive users away.

04Avoid

Leaving store review to the end

Rejections over payments, login options, account deletion or privacy labels can delay launch. Check requirements while designing, not after building.

Choosing a platform approach

The choice between native and cross-platform is mostly about device features and team shape. If the app is largely forms, lists, maps and payments, a shared codebase in React Native or Flutter covers both stores well. If it depends on low-latency audio, complex graphics or new operating system features, native code pays off.

Consider who will maintain it. A cross-platform app still needs people who understand each platform’s build tools, signing and quirks. Mixing approaches is common: shared screens with native modules for the few demanding features.

Store policy shapes the product

Apple and Google review every release against published policies. Rules on in-app purchases, sign-in options, account deletion, user-generated content moderation and sensitive categories such as health, finance and gambling can change which features you build and how you charge.

Read the relevant sections while scoping and keep a short compliance checklist for each release. Prepare reviewer notes and demo accounts in advance, since unclear functionality is a common cause of delay.

Designing for unreliable networks

An offline-first app stores data locally and syncs in the background, so screens load instantly and actions are not lost. That needs a local database, a queue of pending changes and rules for conflicts, such as last write wins or server decides.

Not every app needs full offline support, but every app needs graceful behaviour: cached content, clear status when actions are pending, retries with back-off and forms that survive being interrupted.

Permissions, notifications and trust

Each permission should be requested when the user reaches the feature that needs it, after a short explanation in your own words. A refused permission should leave the app usable, with a route back to settings when the user changes their mind.

Push notifications are powerful and easily abused. Let users choose categories, respect quiet hours and measure opt-out rates. A notification strategy that annoys people leads to disabled alerts and uninstalls.

Release management as a feature

Mobile releases cannot be rolled back instantly like a website. Staged rollouts, feature flags controlled from the server and remote configuration let you limit damage and switch features off without a new build.

Crash reporting and performance monitoring from the first beta show problems on devices you do not own. Track crash-free sessions, start-up time and failed network calls per release.

What drives mobile cost

Cost grows with the number of platforms, the range of devices and operating system versions supported, offline sync, real-time features, and integrations with hardware such as Bluetooth devices or wearables.

Ongoing work matters as much as the first build. Each yearly operating system release brings changes, deprecations and new review requirements, and dependencies need updating to stay supported. Budget for maintenance from the start.

FAQ

Questions to resolve before the build.

01Should we build native or cross-platform?

Cross-platform frameworks suit most business apps, content apps and marketplaces, and let one team serve both stores. Native development is worth it for heavy graphics, advanced camera or audio work, or deep integration with new platform features as soon as they appear.

02Do we have to use Apple and Google in-app payments?

For digital content and subscriptions consumed in the app, usually yes, with exceptions that vary by region and over time. Physical goods and real-world services typically use your own payment provider. Check current store rules for your category.

03How do we handle users on old versions?

Version your API, keep older versions working for a defined period and build a minimum supported version check into the app. When a version must be retired for security or compatibility, prompt or require users to update.

04What do the stores require around privacy?

Both stores require privacy disclosures describing the data you collect and how it is used, and Apple requires a way to delete an account created in the app. Tracking across other companies’ apps needs explicit permission on iOS.

05Is a progressive web app enough?

Sometimes. A PWA avoids store fees and review, updates instantly and works on any device, but has limited background behaviour, push support that varies by platform and less visibility in app stores. It suits content and tools more than device-heavy apps.

Primary sources

References behind this page

Dated official documentation, standards, and research that support the factual claims on this page.

  1. 01
  2. 02
  3. 03

How to read this page

Scope, cost and timeline figures are planning guidance until confirmed in a written proposal. Diagrams and screens are illustrations, not client deliverables, and source-code rights and handover follow the signed agreement. See the delivery process and the full disclaimer.

Next decision

Turn the brief into an accepted product scope.

Define outcomes, constraints, evidence, rights and handover before delivery begins.

Commercial rights, repositories, environments, documentation, acceptance and handover remain contract-defined.