Many businesses start their digital journey with a website, and sooner or later someone asks: "could our customers, or our field team, do this from their phones?" The good news: if the web side was built properly, a mobile app is not a project from scratch. The bad news: if all you have is a brochure site, the data layer an app needs probably does not exist yet. This guide helps you work out which situation you are in and which questions to ask.
First, work out what you already have
What drives the cost and timeline of a mobile app most is where and how your data lives on the web side. There are three typical situations:
- Brochure site: pages and a contact form, no user accounts or transactions. The data layer (API and database) has to be built first.
- Site with an admin panel: products, orders or bookings live in a database, but only the site's own pages can reach that data. The data needs to be exposed through a secure API.
- Web application built on an API: the site already reads and writes its data through an API. The app uses the same API, and most of the work is the mobile screens.
Quick test: ask your developer, "could another application read an order from our site, from which address and with what permission?" If the answer is clear, you are in the third situation.
A shared API: one dataset, two interfaces
The healthy way for web and mobile to share data is for both to talk to the same API. The API defines in one place who can see which data, how an order is created and when stock is reduced. If the rules are written in two places they drift apart sooner or later: an order that can be cancelled on the site cannot be cancelled in the app, or the other way round.
A mobile app usually needs a few additions to the API: secure authentication that keeps sessions alive for a long time (refreshable tokens), device registrations for push notifications, and operations that can be retried safely on a weak connection.
Native or cross-platform?
Writing separate native apps for iOS and Android gives the most direct access to each platform but means two codebases. Cross-platform tools such as React Native ship to both stores from one codebase; if the web side is written in JavaScript/TypeScript, the team shares the language and often the same data types. For most business apps (orders, bookings, field records, customer accounts) cross-platform is enough. Heavy graphics, low-level hardware access or very platform-specific features are the cases where native development is worth reconsidering.
What drives the cost
A single number would be misleading; the word "app" covers very different scopes. When comparing quotes, check whether each of these is included:
- Number of screens and flows: sign-in, lists, details, forms, payment, profile...
- Work on the API side: is the existing API enough, or does a data layer have to be built first?
- Offline mode: will records be captured without a connection and synced later?
- Notifications: which events trigger them, and who manages them?
- Device or third-party integrations such as payments, maps, camera or barcode scanning.
- Store release: accounts, screenshots, privacy disclosures and the review process.
- Maintenance after launch: operating system updates require compatibility work every year.
Store accounts should be in your name
App Store and Google Play developer accounts determine the legal owner of the app. If the account is opened in the developer's name, moving to another vendor means a separate transfer process. Have the accounts opened in your company's name and give the developer only the access they need. The same applies to server, domain and push notification accounts.
The phased path we recommend
- Inventory the data and business rules on the web side: which records exist, and who can change what?
- If needed, build or extend the API layer, and connect the website to the same API.
- Start mobile with the single most-used flow (for example placing an order or a field record) and release it.
- Look at real usage data and choose the next feature.
Following this order gets a first version to users without waiting for every feature, and adds each later step on the same foundation. Treating the website, the mobile app and a future ERP connection as parts of one system is the safest way to avoid reaching the "let's rewrite everything" point two years from now.
