Skip to content

Service · Mobile

Custom Mobile App Development

Commission a custom mobile app when you know the job needs a phone in someone’s hand but have not yet fixed how it should be built. We decide with you whether it should be native, shared-code or not an app at all, then design, build, release and hand over the apps together with the services they depend on.

Platform route chosen from device needs, not habit

Apps, backend and admin delivered as one programme

Releases shipped under your own store accounts

Deliverables

What a mobile app development engagement delivers.

01Delivered

A platform decision record

A short written comparison of native Swift and Kotlin, a shared-code stack and an installable web app against your features, users and future team, naming the route and what would make us revisit it.

02Delivered

iOS and Android apps

Production apps on the chosen route, covering sign-in, the core user journeys, push notifications, deep links, offline behaviour where it matters and the permission prompts each platform expects.

03Delivered

The services behind the apps

The API, data model, file storage and background jobs the apps call, or an integration layer over the systems you already run, versioned so older app installs keep working after a server change.

04Delivered

An operator console

A web admin for the people who run the service day to day: user lookup, content and configuration, refunds or credits where money moves, and an audit trail of who changed what.

05Delivered

A release pipeline and store presence

Signed builds produced by CI, TestFlight and Play internal testing tracks, store listings, privacy declarations and the first staged production rollouts, all under accounts you control.

Early decisions

Technical decisions we settle early in mobile app development.

01Decided

Whether it should be an app at all

If users visit once a quarter and need no camera, sensors or notifications, a responsive web product may serve them better. We test that question honestly before recommending a store release.

02Decided

Native, shared code or both

Hardware-heavy features, a strong existing Swift or Kotlin team, or a React web team already in place each push the route in a different direction. Some products share logic and keep native screens.

03Decided

How old an app version you will support

People do not update promptly. We agree the oldest app version and OS release the backend must serve, and build a forced-update path for the day a breaking change is unavoidable.

04Decided

What works without a signal

Field staff, travellers and basement car parks lose connectivity. We decide which screens read from a local cache, which actions queue for later, and how conflicts resolve on reconnect.

05Decided

Identity and account recovery

Email and password, phone OTP, Sign in with Apple, Google sign-in or enterprise single sign-on change onboarding and support load. Apple requires its sign-in option when certain third-party logins are offered, so we settle this early.

06Decided

Notification strategy

Which events justify a push, which belong in an in-app inbox, and how users control them. Over-notifying gets apps muted or deleted, so we design the rules before wiring APNs and Firebase Cloud Messaging.

Engagement

How a mobile app development engagement runs.

  1. 01Phase 1

    Map the jobs and the devices

    We list who uses the product, where they are when they open it, and which phone capabilities each journey depends on, then write the platform decision record for your sign-off.

  2. 02Phase 2

    Prototype the riskiest journey

    The flow most likely to surprise us, such as a payment terminal pairing, a camera capture or an offline sync, is prototyped on real devices before the rest of the backlog is estimated.

  3. 03Phase 3

    Build apps and services in vertical slices

    Each journey is delivered end to end, from database to screen, and lands in your testers’ hands through TestFlight and Play testing tracks so feedback arrives while changes are still cheap.

  4. 04Phase 4

    Staged store launch and handover

    Production releases roll out to a growing share of users while crash and error rates are watched. Your team then receives the repositories, pipeline, store access and a runbook for the next release.

Fit

When a dedicated mobile app is the right choice.

01Good fit

Your product lives in pockets

Couriers, field engineers, patients, drivers and shoppers who act on the move need something faster to reach than a browser tab and able to alert them when it matters.

02Good fit

You need more than one specialist

If the work spans product design, a new backend, two app platforms and store release, one accountable programme is simpler than coordinating four separate suppliers.

03Good fit

The platform route is still open

Founders and product leads who have heard competing advice about native versus cross-platform want the choice made against their product, with the reasoning written down.

Start with the moment of use

A mobile product earns its place when it is used in a moment a laptop cannot serve: a courier at a door, a nurse at a bedside, a shopper in an aisle. We begin by describing those moments in detail, including the lighting, the one free hand and the patchy signal, because they decide more about the build than any feature list.

Those descriptions then become the test for every later choice. A screen that needs two hands, a flow that fails without a connection or an alert that arrives too late is caught on paper, long before it reaches a device.

Choosing the route without ideology

Native Swift and Kotlin give the deepest access to each platform and the newest OS features on release day. Shared-code stacks such as Flutter or React Native let one team serve both stores. An installable web app skips store review entirely. None of these is right by default, and teams often argue for whatever they used last.

We weigh the routes against the hardware your journeys need, the people who will maintain the code, and how closely the two platforms must stay in step. The answer goes into a decision record, so a future engineer can see why the product was built the way it was.

The backend is half the product

Most of what users experience as app quality is decided on the server: how fast lists load, whether a payment confirms, whether yesterday’s data is there on a new phone. We design the API around the screens that consume it, keep responses small for mobile networks, and version it so a server release never breaks installs that have not yet updated.

Store review is part of the schedule

Apple and Google both review apps before release, and both publish rules on payments, privacy declarations, account deletion and permission use. We read those rules against your feature list during discovery, not the week before launch, and we keep content and configuration server-driven so routine changes do not need a new review at all.

Leaving your team in control

Handover is not a zip file. Your engineers receive working pipelines that build and sign both apps, access to the crash and analytics dashboards, and a runbook describing how a release moves from a merged branch to full rollout. If you would rather we stay on, that becomes a separate support arrangement with its own terms.

FAQ

Questions to resolve before the build.

01What drives the cost of a mobile app?

The number of distinct user roles, how many journeys each role has, whether a backend already exists, hardware or third-party SDK integrations, offline requirements and whether one or two platforms ship at once. A shared-code route lowers the second platform’s cost but does not remove it, because testing, store work and some native code are still per platform.

02How long does a mobile build take?

It depends on scope fixed after discovery, the readiness of any systems we integrate with, how quickly your side can review builds and supply content, and store review on both platforms. We give a dated plan once the platform decision and the first prototype have removed the biggest unknowns, not before.

03What do we receive at the end?

Source repositories for the apps, backend and admin console, infrastructure definitions, the CI pipeline, store listings and signing set up under your accounts, architecture notes, the platform decision record and a release runbook your engineers can follow without us.

04Who owns the code and the store listings?

You do. Code, designs and documentation are assigned to you under the contract, apps are published from your Apple Developer and Google Play accounts, and signing keys are held in your vault rather than ours.

05How is the work accepted?

Each journey has written acceptance criteria agreed before it is built. Your testers check it on a TestFlight or Play testing build, raise defects against those criteria, and sign it off once they pass. The final release is accepted against the full list plus agreed crash and performance checks.

06What is outside the scope of this service?

Running your app after handover, marketing it, writing store copy beyond the listing basics, and paid user acquisition. Ongoing upkeep is available separately as retained maintenance; we name anything else that is out of scope in the statement of work.

Primary sources

References behind this page

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

  1. 01
    Apple App Store Review Guidelines

    Apple’s rules for apps on the App Store, including sign-in, payments and privacy.

  2. 02
    Google Play Console Help

    Google’s documentation on publishing, testing tracks and staged rollouts.

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.