The ask
This was a client project: an e-commerce platform for career management plus a marketplace for expert know-how. The client wanted exactly two things.
- Both a web app and a mobile app
- In two months
The team was me on the frontend and one backend developer. Once we got going, though, the workload had grown to 3–4x the original wireframes.
- A whole admin console got added. Not just product, article and user management, but every small thing down to editing the filter option lists.
- Existing features grew too. Sign-up wasn't just sign-up anymore. Profile setup, interest selection and more got chained on, and sign-up alone ended up as four routes. My Career (the résumé manager) was even bigger: every résumé section — education, work history, projects, certifications, languages — got its own input screen, plus per-section visibility settings and résumé layouts on top.
On top of that, we had to build both a desktop and a mobile layout, which doubled the screen work again. And this was before Figma MCP existed, so every screen had to be translated from the design by hand. "We'll just push hard and make it" didn't add up.
Cut the scope first
So before writing any code, I turned the wireframes into a feature list. I broke things down by feature rather than by page, and gave each one a priority.
The rules were simple.
- Does the service break without this? (login, browsing products, checkout and so on)
- Could we ship it later without users really noticing?
Sorting it that way, the realistic line was finishing about 70% within the two months and continuing the rest during the maintenance period. We agreed on that with the client. When a schedule is tight, settling "this by then, that by later" up front is a lot less painful for everyone than saying "we'll do it all."
One web app + one mobile app = two projects
Cutting scope still left one problem. The client wanted web and app, and taken literally that means building two projects in two months.
So we proposed a WebView. Build one good web app, and make the mobile app a shell around it.
The setup
The setup is simple.
- Build the web app with React (Vite). This is where nearly all the work goes. It's responsive, designed mobile-first.
- Wrap it in a WebView inside a React Native app. The app is little more than a shell.
- Keep checking how it looks in the app on the Android Studio emulator while working.
The app-side code was pretty much just this:
function App() {
return (
<SafeAreaView style={{ flex: 1 }}>
<WebView source={{ uri: "http://10.0.2.2:5173" }} style={{ flex: 1 }} />
</SafeAreaView>
);
}10.0.2.2 is the address the Android emulator uses to reach your machine's localhost. With the Vite dev server running, the app in the emulator hot-reloads just like the browser does, so I could keep my usual web workflow and watch the app screen alongside it. For production you'd just swap that address for the real domain.
A fix on the web shows up in the app right away, so each screen only gets built once. The app only needs a new build and release when the shell itself changes. Being able to respond to spec changes with a web deploy, without going through app review again, was another plus. For an early-stage product whose plans keep shifting, that matters more than you'd think.
App-only work, planned in parallel
A WebView doesn't make the app work zero. At the time, all I knew was "to get onto the store, you need to add a few app-only features on top of the web code." When I looked into it later, there was more to it.
1. An app that just wraps a website can get rejected
Apple's App Review Guideline 4.2 (Minimum Functionality) names apps that simply repackage a website as a reason for rejection, and Google Play has a similar policy. So you need features that only make sense in an app, like push notifications. That's what the "app-only features" I'd heard about meant.
2. Payments work differently than on the web
Korean payment gateway checkouts call out to card company apps or easy-pay apps mid-payment. A browser handles that hand-off on its own, but a WebView can't open non-http addresses like intent:// or card app schemes by default. The native side has to intercept those requests, open the external app, and bring the user back into the app once payment finishes.
3. Selling digital goods means dealing with store billing policy
This service sold expert know-how as digital content like PDFs. Selling digital goods inside an app puts you under the stores' in-app billing policies. Korea allows third-party billing thanks to a law change, but a fee still applies. It's a cost that never existed on the web and shows up only in the app.
We planned to do this app-only work in parallel, timed to when web development wrapped up. With the screens and core features done on the web first, all that would be left on the app side was native integration and policy work.
So did it ship?
Short answer: it never made it to the app stores. Around the time development was wrapping up, the client decided to shut the business down quickly, and the project ended before notifications, payments or the store release.
It's a shame, but looking back, this setup also kept the loss small. If we'd been building web and app separately, both would have ended half-built. Because we went with a WebView, at least the web app was left finished.
Looking back
A WebView isn't always the answer. For apps heavy on animation and gestures, or apps that lean hard on native features like the camera or Bluetooth, going native or full React Native from the start is the right call. No matter how much you polish a WebView, it never quite feels like a native app.
Still, under conditions like these, I'd make the same choice today.
- Short timeline, small team
- Most screens are web-like: content browsing, lists, forms
- The plan is likely to keep changing
But if I did it again, I wouldn't push the app-only work to "we'll do it in parallel later." I'd research it at the start. Review policy and in-app billing fees aren't code problems, they're product and cost problems, and the later you find out, the more you have to renegotiate with the client.
In the end, this project came down to two things: doing less (70% scope) and never doing the same work twice (WebView). That judgment mattered more than the choice of technology.