Mobile App Development

Mobile apps that feel native, from one codebase.

You need iOS and Android. You don’t need two native teams, two backlogs, and two release cycles to get there. We build cross-platform apps in React Native, Flutter, and Expo, and the first build reaches your phone through TestFlight in week two.

Scope your app

What we build

What lands in your App Store Connect account.

These are artifacts rather than capabilities. Every item below is something you can open, install, or ship on the day we hand it over.

A cross-platform app in React Native and Expo

One TypeScript codebase for iOS and Android, sharing types with your web backend so a schema change breaks the build instead of production.

Offline-first storage with a real sync layer

SQLite on device, a write queue, and conflict resolution you can inspect. The app works in a basement lift and reconciles when signal returns.

Real-time sync between phone and dashboard

Postgres changes streamed over WebSockets. An edit made on the phone lands in your web admin in under a second, without a pull-to-refresh.

Push notifications wired to APNs and FCM

Per-user routing, quiet hours, and deep links that open the exact record rather than dumping the user on the home tab.

A native client for your existing SaaS

We consume your API and build real screens. No WebView wrapper, because Apple rejects those under guideline 4.2 and users can feel the difference.

App Store and Google Play submission

Screenshots at every required size, privacy nutrition labels, the Play data safety form, and review notes. We push the first build and answer the first rejection.

Device, Bluetooth, and wearable integrations

BLE peripherals, barcode scanning, HealthKit and Health Connect, and an Apple Watch companion when the product genuinely belongs on a wrist.

How we approach it

React Native by default. Native when the product earns it.

React Native is the right call for roughly four out of five apps we get asked about. You share 90 to 95 percent of the code across iOS and Android, you hire from a much larger pool, and a TypeScript engineer who knows your web app can read your mobile app on day one. It’s the wrong call in specific, nameable cases. Custom camera pipelines, real-time video processing, ARKit scene work, and audio DSP all fight the bridge. If your product lives in one of those, you want Swift and Kotlin, and we’ll say so on the first call rather than after you’ve signed.

Flutter earns its place when you want the same frame on every device. Impeller paints every widget itself, so an Android 9 budget phone and a current iPhone render identically instead of inheriting different platform controls. The cost is real. You write Dart, so you stop sharing types, validators, and utilities with the Next.js web app we build alongside it, and your hiring pool narrows. We pick Flutter when the design demands it or your team already ships Dart. Otherwise React Native wins on total cost of ownership.

Offline-first is a data model decision, and it belongs in week one. Retrofitting sync into an app built on request-response reliably takes longer than building it correctly the first time, so we settle it before anyone draws a screen. We ask which entities a user can edit while disconnected, what happens when two devices touch the same record, and whether last-write-wins is acceptable or you need a merge the user can actually see. Most products want a queue of intents rather than a queue of rows. “Mark invoice 4471 paid” replays cleanly against a server state that has moved on. A blind row overwrite silently destroys someone else’s edit.

Cross-platform apps go slow for the same three reasons every time. Animations run on the JavaScript thread, lists are not virtualised, and too much chatter crosses the bridge. So we use Reanimated worklets to keep gestures on the UI thread, FlashList for anything past twenty rows, and the New Architecture so native modules are called synchronously. You get a TestFlight build every Friday from week two, which means you’re judging a real app on your own phone weeks before launch. Browse the products we have shipped if you want to see the standard before you talk to us.

The phone build we can describe down to the last decision is Hush, our anonymous encrypted chat app in Flutter. It covers the pairing flow, the database rules that close a key substitution attack, and the calls that stay encrypted through a relay.

The stack

Every tool here is here for a reason we can defend.

App layer

  • React Native and Expo

    Config plugins let us use any native module without ejecting, so the managed workflow stops being a ceiling.

  • TypeScript, strict mode

    The same types cover your API, your web app, and your mobile app. Renaming a field fails at compile time.

  • Expo Router

    File-based routing that reads like the Next.js app directory your web team already knows.

  • Flutter

    We reach for it when pixel-identical rendering across every Android device matters more than shared code.

Data and state

  • TanStack Query

    Caching, retries, and an offline mutation queue in one place instead of three hand-rolled hooks.

  • op-sqlite or WatermelonDB

    A local database that still scrolls at 60fps past 100,000 rows. AsyncStorage does not.

  • Zod

    One schema validates the API response on the server, the web client, and the phone.

Backend

  • Supabase

    Postgres, auth, realtime, and row-level security without writing an auth service from scratch.

  • Node with Fastify

    We use it when the business logic is genuinely yours and doesn’t belong in a database policy.

  • Firebase Cloud Messaging

    Push delivery on Android that survives aggressive OEM battery managers.

Motion and release

  • Reanimated 3 and Gesture Handler

    Animations run on the UI thread, so a busy JavaScript thread can’t drop your swipe to 20fps.

  • EAS Build and EAS Update

    Over-the-air JavaScript fixes reach users in minutes rather than waiting on a store review.

  • Sentry and Maestro

    Crash traces with readable source maps, and end-to-end flows that run against every pull request.

Cost and timeline

What a mobile app costs, published before you call us.

Most studios make you book a call to find out. These are the bands comparable work has landed in, and your own quote is fixed before kickoff rather than after a discovery phase spends three weeks of your runway.

Mobile client for an existing product

$20,000 to $32,000

4 to 6 weeks

Your API already exists. We build the screens, auth flow, push notifications, and both store listings.

MVP from scratch

$24,000 to $40,000

6 to 9 weeks

App, backend, admin view, and both submissions. Enough real product to put in front of paying users.

Full product with offline sync

$40,000 to $60,000

10 to 14 weeks

Offline-first data layer, real-time sync, payments, multiple roles, and analytics wired end to end.

Post-launch support

From $2,500 per month

Rolling, 30 days notice

OS upgrades, store policy changes, crash triage, and a fixed block of feature hours each month.

The bands above are estimates, shown in US dollars and drawn from comparable work already delivered, because no two projects carry the same scope. Your own quote is not an estimate: it is fixed in writing after scoping, before kickoff, and it does not move.

Four variables move the number more than anything else. Offline sync adds roughly two weeks and about a third of the build cost, because conflict handling touches every screen that writes data. Native modules such as Bluetooth, background location, or a custom camera add real integration time and real device testing. In-app purchases cost more than Stripe, since receipt validation is a subsystem of its own and Apple takes 15 to 30 percent forever. And design from a blank page costs more than design against an existing system, which is the saving most teams underestimate.

Offshore studios tend to skip the next part. You own the code from the first commit, in your GitHub organisation rather than ours. You own the Apple Developer and Google Play accounts, so we never hold your release keys or your listing hostage. Payment is 50 percent on contract and 50 percent on delivery, and above $30,000 it splits into milestones drawn against builds you’ve already installed and used, which is most of the work on this page. If the engagement stops, you keep a running app and a repository with readable commit history, not a zip file and a handover call.

We’re a software house in Lahore working with founders across the US, UK, and Gulf, so the timezone question gets a straight answer. Lahore is UTC+5. You get five working hours of overlap with London and three with New York mornings, and we hold the standup inside your window. A mobile build often wants an AI automation layer behind it, handling document capture or classification server-side so the app stays thin. Tell us the constraint and we’ll scope it in a 30-minute call.

FAQ

The questions that decide it.

A cross-platform MVP built from scratch runs $24,000 to $40,000 and ships in six to nine weeks. Adding a mobile client to a product whose API already exists starts around $20,000. Those figures are estimates in US dollars, not quotations; the quote that follows scoping is fixed in writing before kickoff. Offline sync, Bluetooth hardware, and in-app purchases are the three features that move the number most. The scope is fixed with the quote, not left to a discovery phase.

React Native for most products, because you keep sharing TypeScript, validators, and a hiring pool with your web team. Flutter when pixel-identical rendering across every Android device matters more than that sharing, or when your team already writes Dart. Neither one is right for custom camera pipelines or ARKit scene work, which want native Swift and Kotlin.

Yes, and we will not do it by wrapping the site in a WebView. Apple rejects repackaged websites under guideline 4.2, and users notice the scroll behaviour immediately. We consume your existing API, build real native screens for the three or four workflows people actually perform on a phone, and add push notifications and offline reads. That work usually takes four to six weeks.

Both, including the first rejection. We prepare screenshots at every required size, write the privacy nutrition labels and the Play data safety form, configure TestFlight and internal testing tracks, and submit under your developer accounts. Apple review typically returns in 24 to 48 hours. If it comes back rejected, we respond and resubmit at no extra cost.

You do, from the first commit. The repository lives in your GitHub organisation and we work inside it as collaborators. The Apple Developer and Google Play accounts are registered to your company, so signing certificates and release keys never sit with us. IP assignment is written into the contract. We sign your NDA or ours, whichever you prefer.

Lahore is UTC+5. That gives you roughly five working hours of overlap with London and three with New York mornings, and we schedule the standup inside your window rather than ours. Async is the default regardless. You get a shared Slack channel, a TestFlight build every Friday, and a written update waiting before your day starts.

Tell us what the app has to do.

Send us the feature list, or a paragraph and a rough deadline. You get a fixed-scope quote and a week-by-week plan within two working days.