Convert Figma Make to an Android App and Ship It on Google Play

Key takeaways

Figma Make publishes web apps, not Android apps. Your packaging options are a WebView wrapper, a Trusted Web Activity or Capacitor around the exported code – each with different hosting needs.
Hosting decides a lot on Android: TWAs and verified App Links need /.well-known/assetlinks.json, which is easiest to serve when you deploy the exported code yourself.
Prototype habits – dead buttons, sample data, mock logins – are Broken Functionality risks on Google Play. Fix them before the 14-day closed test starts, not during it.
WebViewGold for Android, built by our team, adds push, offline fallback, App Links, biometrics, scanners and Play Billing; appsubmitter.io runs signing, Play Console and submission.

Our recommended solution

Turn your Figma Make app into a real Android app with WebViewGold

WebViewGold wraps the Figma Make web app you already have in a native Android Studio project and adds push notifications, a native offline screen, deep links, a QR scanner and more – the native value reviewers at Google Play look for. Built by our own team, and we submit WebViewGold apps all the time.

Get WebViewGold How it helps ↓

Can you convert a Figma Make project into an Android app?

Yes. You convert Figma Make to an Android app by packaging the web app it generates – served from figma.site, a custom domain or your own hosting – into an Android App Bundle and releasing it through Google Play Console. Figma documents no Android or Play Store output, so the packaging, the signing and Google's policy declarations are yours.

Two properties of Figma Make shape the Android plan more than the iOS one. First, you can take the code with you: Push to GitHub works on every plan, a .zip download needs a Full or Dev seat, and since July 2026 Make keeps the code in Git and supports any web framework. That makes self-hosting – and with it domain verification – realistic. Second, published Make apps can ask for camera and microphone access, which inside an Android wrapper turns into a chain of runtime permissions. For Apple's side of the story, read converting Figma Make to an iOS app.

WebView, TWA or Capacitor: three Android routes for a Make app

	WebView wrapper (WebViewGold)	Trusted Web Activity	Capacitor project
What the app loads	Your published URL in Android System WebView	Your web app as a PWA in the user's browser, full screen	The exported build, bundled inside the AAB
Hosting requirement	Any stable address: figma.site, a custom domain or your own server	A domain that serves `/.well-known/assetlinks.json`, a web app manifest and a service worker	Only your backend, such as Supabase, has to be online
How UI changes reach users	With every update of the published version	With every deploy	With a new app release
Native capabilities	Ready-made modules: push, offline fallback, App Links, biometrics, scanners, Play Billing	What the browser offers web pages	Whatever plugins you add and maintain
Effort	Configuration	PWA work plus Bubblewrap or PWABuilder	A development project

Two Make specifics tip the scales. Figma doesn't document PWA support, so a TWA means adding a manifest and a service worker to the exported code yourself. And the Figma publishing docs we reviewed don't describe serving custom files under /.well-known/, which a TWA needs to run without a browser bar – otherwise it falls back to a Custom Tab with a toolbar – and which verified App Links need as well. If either matters to you, deploy the exported code to hosting you control. Our Capacitor alternative article compares Capacitor-based setups with wrappers in more depth.

Want your Figma Make app in Google Play without the trial and error?

Book a free consultation call: we check your web app, tell you which native features it needs and what to fix before review. Or hand it off – our App Specialists set up signing and CI/CD, prepare the store listing and submit the app for you.

Free consultation call Book our service →

What Google Play requires from a new app (as of October 2026)

Requirement	What it means for a Make app
Play Console account with a one-time registration fee	Personal or organization; publish under the business that owns the domain the app loads
Closed test with 12 testers for 14 consecutive days (personal accounts created after November 13, 2023)	Start it only once the app is no longer a prototype – our closed testing guide shows how to pass
Android App Bundle with Play App Signing	The wrapper or Capacitor project produces the AAB; keep the upload key safe and note the app signing SHA-256 for `assetlinks.json`
Target API level 36 since August 31, 2026	Check the project before every build – see the target API level guide
Sign-in details for reviewers	A reusable login without one-time codes or two-step verification, valid at all times
Data safety form	Everything your Make app sends to Supabase, AI providers and analytics
Account deletion	An in-app path plus a web page, as soon as users can create accounts
Privacy policy	A public URL entered in Play Console and linked inside the app

Prototype habits Google Play reviewers flag

Google Play doesn't phrase it like Apple's Guideline 5.6, but its functionality and behavior policies catch the same gaps a Make prototype tends to leave:

Broken Functionality. Google doesn't allow apps that "crash, force close, freeze, or otherwise function abnormally" and counts apps that load but don't respond among the common violations. A button that was never wired up is exactly that – see our Broken Functionality guide.
Limited functionality. A static app without app-specific functions falls under Google's Limited Functionality and Content rule; a few screens of generated marketing copy won't pass.
Login walls. A mock login or a code sent to your phone stops the reviewer cold. Sign-in details have to work without one-time passwords.
Listing promises. Screenshots and descriptions must match the build – our metadata policy guide lists the pitfalls.
Different behavior for reviewers. Google's Deceptive Behavior policy expects an app to behave the same for reviewers and regular users, so don't publish new Make features while a release is in review.

Fix these before the closed test begins. Your testers' feedback and your production access answers should be about the real app, not the prototype.

The shortcut from Figma Make to Google Play

WebViewGold: your Figma Make app, native on Android

Instead of building native features from scratch, start from WebViewGold. You get ready-made Xcode and Android Studio projects for your website, with native modules you switch on in the configuration:

Push notificationsOneSignal or Firebase, for real, personal events
Native offline screenNo browser error pages when the connection drops
Native splash screenApp-like start instead of a loading web page
Deep linksLinks open the right screen inside the app
QR & barcode scannerDevice features the website alone can't offer
In-app purchasesNative purchase flows where the store requires them

No tool guarantees an approval: Google still judges what your app offers. Use the native features in your main user journey and keep proving that you own the website – our App Specialists review your WebViewGold app before it goes to Google Play.

Discover WebViewGold Let us submit your WebViewGold app

Android details a Make app needs inside a WebView

Camera and microphone. When a Make page asks for the camera or microphone, the WebView passes that request to the app through WebChromeClient.onPermissionRequest. The app needs CAMERA or RECORD_AUDIO in its manifest, a runtime prompt at the moment of use and a graceful path when people decline – a crash on "Don't allow" is a classic broken functionality finding.
Uploads. File inputs only open a chooser if the app implements onShowFileChooser. Test every upload field on a device.
Notifications. Push needs a native service – Firebase Cloud Messaging directly or through OneSignal or Pushwoosh – and, on Android 13 and later, the POST_NOTIFICATIONS runtime permission.
Back navigation. React or Vue routing lives inside the WebView, so map the system back gesture to its history. With target API 36, predictive back is on by default and the old onBackPressed() path no longer fires.
Edge-to-edge. Recent target levels draw the app behind the status and navigation bars, so give fixed headers and bottom navigation the right insets.
Google sign-in. If you prompted Make for Google login through Supabase, it won't run inside the WebView: Google blocks embedded user-agents and recommends Custom Tabs. Open the flow in a Custom Tab and return through an App Link, or integrate native sign-in with Credential Manager. Never change the user agent to get around the block.
Other domains. Open them in Custom Tabs so the WebView stays on your own app.

Packaging the Make app with WebViewGold for Android

WebViewGold is the website-to-app product made by our own team. It explicitly supports Figma Make projects and comes with a ready-made Android Studio project. The sequence for a Make app:

Fix the source. Either a custom domain on Figma hosting that you won't update during review, or a deploy of the exported code from a release branch.
Configure the project in Android Studio or the separately sold Cloud Builder: start URL, package name (permanent after the first release), app name and icon.
Set a custom user agent so your Make code can hide web-only elements in the app without changing features.
Switch on what the app uses: push via OneSignal, Firebase or Pushwoosh; offline fallback with reconnect; App Links; biometric authentication; QR, barcode and document scanning; geolocation; the native Play review dialog; Google Play Billing with the Extended license for digital goods.
Build a signed AAB that targets API level 36 and enroll in Play App Signing.
Upload to internal testing, read the pre-launch report and fix what it finds before the closed test.

It's a one-time purchase, you own the project and you publish in your own Play Console account. A wrapper makes the native side straightforward, but it can't promise an approval – the Make app inside still has to work.

Closed testing, Data safety and release for a Make app

Closed test. A Make app changes mostly on the web side, so testers see fixes without installing anything new. Keep a log anyway – date, tester, issue and the published update that fixed it. Ship native changes such as permissions, modules or icons as new AABs with higher version codes: Google tells developers to act on feedback during the test, and your production access answers should name both the web and the app changes.

Data safety. Google counts what your WebView content collects as your app's data whenever you control that content. For a Make app, that means accounts and records in Supabase, anything your functions send to AI models, uploaded files, location and analytics. Declare it, align the privacy policy and recheck the answers whenever a prompt adds a feature. Our Data safety guide explains the definitions.

Account deletion and payments. If users can sign up, Google requires an in-app deletion path plus a web page for deletion requests, with its URL in Play Console. Digital goods sold in the app use Google Play Billing; physical goods and services can use other payment methods, and some countries allow alternative billing under specific programs.

Release. Roll out in stages and watch Android vitals for crashes and ANRs in the first days.

appsubmitter.io takes the Play Console work off your plate: developer account and app setup, upload key and Play App Signing, a CI/CD pipeline for AABs, store listing, content rating, Data safety, closed-test planning and communication with the Google Play review team – in your own account. Changes to the Make file or code are quoted separately upfront. Book the Android service or start with a free consultation call. If your iOS submission ran into a Developer Code of Conduct flag, read Figma Make app rejected under Guideline 5.6.

Checklist before you submit

The Make app went through a prototype cleanup: no dead buttons, sample data or mock login.
You chose WebView, TWA or Capacitor and set up hosting to match.
For a TWA or App Links, /.well-known/assetlinks.json is live with your app signing fingerprint.
Camera and microphone requests work with both "Allow" and "Don't allow".
Upload fields, back navigation and edge-to-edge layouts were tested on a real device.
Google sign-in runs in a Custom Tab or natively via Credential Manager – never inside the WebView.
The AAB targets API level 36 and is enrolled in Play App Signing.
Reviewer sign-in details work without one-time codes.
Data safety covers Supabase data, AI processing, uploads and analytics.
Account deletion works in the app and through a public web page.
For a new personal account, the closed test started only after the cleanup.

Frequently asked questions

Can I publish a Figma Make app on Google Play?

Yes, if you package it as an Android App Bundle and it works as a real app. Figma has no Play Store export, so you wrap the published or self-hosted web app – for example with WebViewGold – or build a TWA or Capacitor project, then release it from your own Play Console account after the required testing.

Do I need Android Studio to convert Figma Make to an Android app?

Only if you want to build locally. WebViewGold's Android version is an Android Studio project, but its separately sold Cloud Builder configures and builds the app in your browser. A Capacitor route needs Android Studio and a developer. appsubmitter.io can also run the builds in a CI/CD pipeline and upload the AABs for you.

Can I use a TWA for my Figma Make app?

Yes, but plan for extra work. Figma doesn't document PWA support for Make, so you add a web app manifest and a service worker to the exported code, and your domain must serve /.well-known/assetlinks.json with the app's signing fingerprint. Without that verification, the TWA shows a browser bar. Self-hosting the exported code makes both straightforward.

Why doesn't the camera or microphone work in my Make app on Android?

In a WebView app, a page's camera or microphone request reaches the native code, which must hold the matching permission, ask the user at runtime and then grant the request to the page. If any step is missing, the feature silently fails or the app crashes. Test with "Allow" and "Don't allow" on a real device.

How long does Google Play review take for a new app?

Google publishes no fixed time for reviewing releases. What it does say concerns the production access application after a closed test: that review usually takes seven days or less but can take longer. Add the 14 days of closed testing for new personal accounts, and leave room for a rejection round.

Should I use Capacitor instead of a wrapper for my Make app?

Capacitor makes sense if a developer will maintain the native project and you want the UI bundled inside the app. A wrapper fits better if Figma Make stays your main editor and updates should go live with each publish. Either way, Google reviews the same thing: whether the app works and offers real functionality.

Sources and further reading

Store policies and third-party products change regularly – always check the current versions. This article is independent advice and not affiliated with or endorsed by Apple, Google or any other company or product mentioned; all trademarks belong to their owners. WebViewGold and appsubmitter.io are made by our team at jocapps GmbH.

Convert Figma Make to an Android App: Hosting, Packaging and Google Play Release