Updated November 2026 · Written and maintained by the Progression Agency strategy team
Three routes answer “how to create mobile app from website”: make the site an installable progressive web app, wrap it in a native shell for the App Store and Google Play, or rebuild the app natively on the backend the website already uses. The right one depends on what people should do in the app that they cannot do on the site today. Apple’s review rules turn away apps that are only a repackaged website, and Google Play asks for real app functionality, so the wrapper route works only when the app adds something. Progression’s developers, designers and strategists are based in New York and build all three routes for companies across the US.
On this page · 15 sections
- An ordering site wrapped and sent back
- How to create mobile app from website: three routes side by side
- Route one: the website becomes an installable web app
- Route two: a native shell around the site
- Route three: a native or cross-platform rebuild on the same backend
- Apple’s Guideline 4.2 and the repackaged website
- Google Play’s rules for webview apps
- Features that earn a place on the home screen
- Logins, data and analytics shared between site and app
- Store accounts, fees and testers
- What one click builders leave out
- Keeping the website and the app in step
- What each route costs
- A route finder for your website
- How Progression turns a website into an app
No website behind the app yet? The path from idea to launch, for an app with no website behind it, is on our how to build an app page.
Examples marked “Illustrative example.” are hypothetical, and no real business, app or website is shown.
An ordering site wrapped and sent back
Picture a hypothetical bakery chain with four shops and a mobile ordering site that customers like. The first app is that site inside a WebView with a new icon, and App Review returns it with a note citing Guideline 4.2, Minimum Functionality.
The second version runs on the same site and the same ordering system. What changed is what the app does that the browser did not: favorite orders saved on the phone, an alert when a pickup is ready, sign in that stays put, and a shop finder that uses location. That is the whole lesson of the route choice.
- Start from what customers do on the site most often.
- List what an installed app could do better for those tasks.
- Pick the route that delivers that list at the lowest build cost.
- Keep the website as the backend and the source of content.
How to create mobile app from website: three routes side by side
Each route keeps a different share of the website and reaches the phone in a different way. The table compares them on the points that decide the choice.
| Route | Installed from | Code you keep | Device access | Store rules that apply | Best fit |
|---|---|---|---|---|---|
| Installable web app | The browser, or Google Play through a Trusted Web Activity | All of it; the site is the app | What the browser allows | Only if listed in a store | Content, booking and account sites |
| Native shell (Capacitor, or a Trusted Web Activity on Android) | App Store and Google Play | The web front end, plus a native layer | Native SDKs through plugins | Apple 4.2 and Play’s functionality and webview rules | Sites that need store presence and a few device features |
| Rebuild on the same backend | App Store and Google Play | The backend and APIs | Full | Standard review | Apps people open daily, or offline first work |
The routes are not exclusive. A business can ship an installable web app first, add a native shell for the stores when customers ask for it, and rebuild the busiest screens later, all on the same backend.
Which route fits a site that mostly publishes articles?
An installable web app, in most cases. Readers gain an icon, faster repeat visits and offline reading, and the site stays one codebase. A store app for content alone runs into Apple’s rule against web clippings and aggregators unless it adds something readers use, such as saved issues or alerts they choose.
Route one: the website becomes an installable web app
A progressive web app is the website, built so a browser can install it like an app. Per MDN’s guide to making PWAs installable, the site needs a web app manifest referenced from every page and must be served over HTTPS. Chromium browsers look for these members:
| Manifest member | What it does |
|---|---|
| name or short_name | The app’s name on the home screen and install prompt |
| icons | Must include a 192 pixel and a 512 pixel icon |
| start_url | The page the app opens on |
| display or display_override | Standalone or fullscreen opens it as an app, without the browser bar |
| prefer_related_applications | Must be false or left out |
A service worker is not required for installation, but it is what lets pages open offline, so most installable web apps carry one. Install support varies. On Android, Chrome on devices with Google Mobile Services and Samsung Internet install the app as a full app entry; other Android browsers add a browser badged shortcut.
The service side of this route, from manifests to offline caching and push strategy, is the work of our progressive web app development team, and that page goes deeper on it.
Home Screen web apps on iPhone and iPad
Since iOS 16.4, people can install a web app from the Share menu in Safari, Chrome, Edge, Firefox and Orion, and a manifest set to standalone or fullscreen makes it open as its own app. The same release brought Web Push and app badges to Home Screen web apps, with notifications on the Lock Screen and a paired Apple Watch, according to the WebKit announcement. There is no browser install prompt to trigger on iOS, so the site shows its own short install guide.
- Install comes from the Share menu, so place a short guide where it helps.
- Ask for alerts only after a tap, such as a subscribe button.
- Use badges for counts the customer cares about.
- No Apple Developer Program membership is needed for web push.
Route two: a native shell around the site
A native shell is a real iOS or Android app whose screens come from the website’s code. It gets a store listing, a native icon and native features, while most of the interface stays web. Two tools dominate: Capacitor for both platforms and the Trusted Web Activity for Android.
Capacitor describes itself as a cross-platform native runtime: web code runs in a native container, with a plugin API in Swift on iOS and Java on Android for device features, and it can be added to an existing modern JavaScript project. A Trusted Web Activity opens a site full screen in the user’s own browser, in Chrome on Android 72 and later, once Digital Asset Links prove the app and the site share an owner.
| Question | Capacitor | Trusted Web Activity | Bare WebView wrapper |
|---|---|---|---|
| Platforms | iOS, Android and web | Android | Whatever is wrapped |
| Who renders the site | A native web view inside the app | The user’s browser, full screen | A web view inside the app |
| Native features | Plugins in Swift and Java | Few; the app is the site | Only what is hand coded |
| Ownership check | Not applicable | Digital Asset Links prove one owner | None |
| Store risk | Low when the app adds real features | Low when the site is a sound web app | High under Apple 4.2 and Play’s rules |
Capacitor or a Trusted Web Activity?
Capacitor when the app needs iOS as well as Android, or needs device features through plugins. A Trusted Web Activity when the site is already a sound installable web app and the goal is a Google Play listing with nothing extra. Google notes that the host app cannot read the site’s cookies or local storage, and that the site must work well in the browser first.
Why is a bare WebView the riskiest version?
Because it adds nothing a reviewer can see. A WebView that loads the mobile site, with no saved data, alerts or device features, is the exact case Apple’s Guideline 4.2 and Google Play’s functionality policy describe. For a full framework comparison, see our Ionic app development and cross-platform app development pages.
Route three: a native or cross-platform rebuild on the same backend
A rebuild writes new app screens and keeps the website’s backend: the database, the accounts, the content system and the APIs. Nothing customers rely on moves, and the app gets interfaces made for thumbs, gestures and offline use.
- React Native app development for one codebase on iOS and Android, close to a React website.
- Flutter app development for one codebase with its own drawn interface.
- Native app development in Swift and Kotlin for the most demanding screens.
- iOS app development and Android app development when one platform leads.
Which parts of the website carry over?
The backend, the accounts, the product or content data, the payment provider and the analytics events, if the site exposes them through APIs. Screens, navigation and offline behavior are new. If the site has no API layer, adding one is the first piece of work, and the website can use it too. Our web app development team builds that layer.
- APIs reused as they are, or wrapped where they are missing.
- One sign in for web and app accounts.
- Content managed once and shown in both.
- Analytics events named the same on both sides.
Apple’s Guideline 4.2 and the repackaged website
Apple’s App Store Review Guidelines, last updated October 16, 2026, are direct about websites. Under 4.2, an app should include features, content and UI that elevate it beyond a repackaged website, and one that is not useful, unique or app-like does not belong on the App Store.
| Guideline | What it says, in short | What it means for a website app |
|---|---|---|
| 4.2 | Features, content and UI beyond a repackaged website | The app must do something the site does not |
| 4.2.2 | Apart from catalogs, not mainly marketing, ads, web clippings, aggregators or link lists | A brochure site wrapped as an app is the clearest case for rejection |
| 4.2.3 | Works on its own without another app | No step that sends people out to install something else |
| 4.2.6 | Apps from an app generation service are rejected unless the content owner submits them | The business submits under its own developer account |
| 4.3(a) | One app with variations, not a copy per city or location | One app for every branch, with a location picker |
| 2.5.6 | Apps that browse the web use Apple’s WebKit framework | Web content in an iOS app renders through WebKit |
Guideline 4.2.6 matters for anyone looking at an app generation service: apps produced that way are rejected unless the provider of the content submits them directly. A business that wants its app in the store submits it under its own developer account.
What makes an app feel app-like to a reviewer?
Something a person can do in the app that the mobile site does not offer as well: data kept on the phone, alerts tied to their own activity, device features used for a purpose, and navigation built for the app rather than copied from the site. Describe those features in the review notes so the reviewer finds them.
Have a website people already use?Send the URL and the three things customers do most on it. You get a free proposal naming the route and what the app adds.
Get a free proposalTell us about a project you’d like help with.
Google Play’s rules for webview apps
Google Play’s spam policy does not allow apps whose primary purpose is to drive affiliate traffic or to provide a webview of a website without permission from the website’s owner or administrator. Its functionality policy adds two more tests.
- Limited functionality: static apps without app-specific features, such as text only or PDF apps, are not allowed.
- Broken functionality: apps that crash, will not install, will not load or do not respond are not allowed.
- Webview of someone else’s site: not allowed without the owner’s permission.
- Repetitive content: apps should add original content or services.
Your site, your permission
Wrapping your own website clears the permission question in Google’s webview rule, and a Trusted Web Activity goes further by proving with Digital Asset Links that the app and the site share an owner. The functionality tests still apply, so the app needs the same real features Apple looks for.
Features that earn a place on the home screen
Both stores ask the same question in different words: what does the installed app do? These features answer it, and they are also the ones customers notice.
- Saved items, orders, tickets or documents that open offline.
- Push alerts tied to the customer’s own account or order.
- Sign in that stays, with face or fingerprint where the platform offers it.
- Camera for scanning, location for nearby shops, or other device use with a purpose.
- Navigation and screens built for the app, not copied from the site menu.
- Home screen badges for counts the person asked for.
Interface work for those screens sits with our mobile app design team, so the app does not read as the website with a new frame.
Logins, data and analytics shared between site and app
Customers expect one account. Whatever the route, the app should sign in against the same accounts the website uses, keep the person signed in between sessions, and show the same orders, bookings or saved items in both places.
- Use the website’s existing account system rather than a second one.
- Keep the session securely on the device so people are not asked to sign in each time.
- Show the same history in the app and on the site.
- Name analytics events the same way on web and app so reports line up.
- Write the privacy details for the store listings from what the app actually collects.
For a store that sells online, the same backend also carries the catalog, cart and checkout; our ecommerce app development page covers shopping apps in depth.
Store accounts, fees and testers
A web app installed from the browser needs no store account. The two store routes need one per store, and each store has its own steps before the public can download. Once the app is in the App Store, paid promotion is a separate task, which our guide to Apple Search Ads describes.
| Store | Account cost | Before public release |
|---|---|---|
| Apple App Store | $99 a year, Apple Developer Program | TestFlight for up to 10,000 external testers; App Review |
| Google Play | US$25 once | New personal accounts: closed test, 12 testers for 14 days; then production access |
Apple’s Developer Program membership is $99 a year and includes TestFlight. Google’s Play Console registration is a one time US$25 fee, and personal accounts created after November 13, 2023 must run a closed test with at least 12 testers for 14 days before applying for production access.
Pricing depends on scope and is confirmed in a written proposal. Published prices are subject to change.
What one click builders leave out
Plenty of services promise to “convert website to app” in minutes. Most produce the wrapper this page warns about: the mobile site in a WebView, a splash screen, and sometimes a push service bolted on.
A “turn website into app” button can be fine for a demo on your own phone. For a store listing, check three things first: who submits the app, since Apple’s Guideline 4.2.6 rejects apps from app generation services unless the content owner submits them; what the app does beyond the site; and who owns the code and the store account afterward.
- Ask who appears as the developer in the store listing.
- Ask which features exist only in the app.
- Ask whether the code can be moved to another team.
- Ask what happens to the app if the subscription ends.
Keeping the website and the app in step
Each route updates differently. An installable web app changes the moment the website changes. A Trusted Web Activity shows the live site, so content and layout follow the site too. A Capacitor app carries its web code inside the build, so most changes ship as a store update, and a rebuild has its own release cycle on each platform.
Do website changes reach the app on their own?
On an installable web app and a Trusted Web Activity, yes, because the app is the site. In a Capacitor app or a rebuild, content from the backend updates at once, while changes to screens and features go out as new store releases. Plan a release rhythm and keep both stores’ listings current; our mobile app maintenance team runs that work.
- Content from the backend: updates everywhere at once.
- Web app screens: update with the site.
- Shell or rebuild screens: ship as store releases.
- Operating system updates: test each year when Apple and Google release them.
What each route costs
The bands below run from the typical low to the published high in the US market for each route. Store fees are separate and small: $99 a year for Apple and US$25 once for Google.
| Route | Typical low to published high | What the work covers |
|---|---|---|
| Existing site to installable web app | $10,000 to $30,000 | Manifest, service worker, offline pages, install prompts |
| Native shell with app features | $25,000 to $80,000 | Shell, plugins, push, store builds and submission |
| Cross-platform rebuild, iOS and Android | $40,000 to $160,000 | App screens in React Native or Flutter on existing APIs |
| Native rebuild, iOS and Android | $100,000 to $250,000 | Swift and Kotlin apps on existing APIs |
Progression’s price is set in the written proposal, after scope, and is subject to change. Our app development cost guide explains what moves an app budget, from platforms to backend work.
What moves the cost within a route?
How much of the site is ready for phones, whether APIs exist, how many native features the app needs, how many user types sign in, and whether the app must work offline. A sound mobile site with APIs sits at the low end of its band.
A route finder for your website
Four questions settle most cases. Answer them in order and stop at the first clear answer.
- Fix the mobile website first if it is slow or hard to use on a phone.
- Choose an installable web app when people mostly read, browse, book or check status.
- Choose a native shell when the store listing, alerts or a few device features matter.
- Choose a rebuild when the core screens are used daily, need gestures or must work offline.
How Progression turns a website into an app
Progression’s team builds all three routes: installable web apps, Capacitor and Trusted Web Activity apps, and native or cross-platform rebuilds on the website’s backend. When a business asks how to create mobile app from website code it already owns, the work starts from the tasks customers do on the site, picks the route that serves them best, and handles store accounts, submission and updates.
- Route chosen from the site’s real customer tasks.
- App features defined before any build starts.
- Store submission under the client’s own developer accounts.
- Code and accounts owned by the client.
- Maintenance and release planning after launch.
For the wider service, see our app development agency page. Once the app is live, mobile app SEO helps it rank in the stores and our app marketing agency brings the first users.
What this page leaves out: the Progression Method, proprietary and reserved for clients. Reach out to learn more
Getting found in search
AI, AEO and what is changing
Paid media and lead generation
Websites and design
Choosing and working with an agency
Software and app development
Website design by industry and type
Web development, platforms and hosting
Social, content and brand
By industry and by situation
Frequently asked questions
How do I create a mobile app from my website?
Is a progressive web app a real app?
Can an iPhone install a website as an app?
Will Apple accept an app that only shows my website?
Does Google Play allow apps built on a webview?
What is a Trusted Web Activity?
What does Capacitor add to a website?
Do I need separate code for iPhone and Android?
Will customers get alerts from the app on their lock screen?
Will my website login work inside the app?
Do updates to my website show up in the app?
Is a one click “turn website into app” service enough for the App Store?
What does a “convert website to app” builder usually leave out?
Which route costs the least?
What does it cost to put a website in the app stores?
What do Apple and Google charge for a developer account?
What makes an app feel app-like to a reviewer?
When is a rebuild better than a wrapper?
Can the app reuse my website’s backend?
Will an app take search traffic away from my website?
Can Progression turn our website into an app?
Have a website people already use?Send the URL and the three things customers do most on it. You get a free proposal naming the route and what the app adds.
Get a free proposalTell us about a project you’d like help with.
Get a free marketing proposal
Tell us what you are trying to grow and we will come back with a plan, not a pitch deck. Same-day reply on weekdays.
