Turning an existing Shopify store into a mobile app sounds straightforward until the real product and release process begins. The challenge is not simply putting a website inside an app: the mobile experience needs its own navigation, product browsing, cart, customer account, checkout, loading states, error handling, and release workflow while the existing Shopify store remains the commerce backend.
This is the story of how we handled that process at Pivenor Labs for Ritu Fashions, an ecommerce store powered by Shopify — from the first Storefront API connection through customer accounts, cart persistence, Shopify Checkout, Razorpay, Android testing, and Google Play publication.
The goal: a mobile storefront without rebuilding commerce
The objective was not to create a second ecommerce backend. Shopify was already handling the store's products, customers, cart, orders, and checkout, so the mobile app was designed as a dedicated customer-facing mobile experience on top of that existing system. This fits the broader mobile app development services we provide at Pivenor Labs.
That meant building the mobile pieces Shopify does not provide as a ready-made app UI: a reusable header and bottom navigation, collection grids, product detail pages, variant selection, wishlist behavior, cart management, customer account screens, and the loading and error states around them.
The app talks directly to Shopify's public Storefront API for storefront data. Customer authentication uses Shopify's New Customer Accounts flow, while customer tokens are stored securely on the device. There is no custom commerce database sitting between the app and the store.
Keep Shopify as the source of truth. The mobile app should improve the shopping experience without creating a second system that has to be synchronized with Shopify.
The architecture
The resulting architecture is intentionally lightweight. The Expo/React Native app owns the mobile experience and state around it, while Shopify remains responsible for the underlying commerce data and checkout.
Ritu Fashions Android App
↓
Shopify Storefront API
↓
Products · Collections · Cart
Shopify Customer Accounts
↓
OAuth + PKCE · Secure device session
↓
Orders · Addresses · Account details
Cart → Shopify Checkout Kit
↓
Shopify Checkout → RazorpayThe app uses Shopify's public Storefront API directly rather than introducing a custom backend just to mirror products or orders. The cart is persisted locally by its Shopify cart ID, while Shopify remains the source of truth for the actual cart contents. This kept the infrastructure small and avoided maintaining a second commerce database.
The authentication challenge
Customer authentication was one of the more technical parts of the build. Ritu Fashions uses Shopify's New Customer Accounts, so the app does not collect or store a customer password. Instead, Shopify's hosted authentication handles the sign-in flow and email verification.
Under the hood, the mobile app uses OAuth 2.0 with PKCE through Expo's authentication tooling. Access and refresh tokens are stored with secure device storage rather than ordinary application storage. We also had to handle a mobile-specific edge case: on Android, the hosted authentication flow can return through a deep link after the app process has been recreated, so the pending PKCE verifier and callback handling had to survive that situation safely.
We then built the customer-facing account experience around that session: profile details, order history and order details, saved addresses, default-address handling, and account-detail editing.
Preparing the Google Play organization account
Because the app was being published under Pivenor Labs, the Google Play account needed to represent the organization rather than an individual developer account. That introduced a separate platform-verification track alongside the app development itself.
We completed the organization verification process using the business's D-U-N-S information and supporting registration and PAN documentation. Separating this from the app implementation was important: while the Play organization was being verified, the mobile build could continue through its own testing and release preparation.
Testing the app before publication
The app was not treated as finished simply because the screens rendered. The implementation included real Shopify flows for product browsing, variants, cart creation and persistence, Customer Account authentication, orders, addresses, and Shopify Checkout.
On Android, we tested the important flows on a physical device because browser testing cannot prove native behavior such as secure storage, deep-link authentication callbacks, keyboard handling, safe-area layout, gestures, and the embedded checkout experience. Shopify Checkout was presented through Shopify's Checkout Sheet Kit, with Razorpay appearing inside the hosted checkout rather than through a separate Razorpay SDK in the app.
There were also platform-specific problems to solve along the way. For example, Android's embedded checkout behavior around UPI required investigation outside the React Native UI layer, and the final test checklist kept unverified Android cases separate instead of treating code completion as proof that they worked.
The first Google Play review
We submitted the app for review on Friday, September 4, 2026, at around 6:56 PM. Because that was already Friday evening, the weekend accounted for most of the elapsed wall-clock time.
The submission was published on Monday, September 7, 2026, at 12:09 PM. In practical working-time terms, that worked out to roughly three to four hours after the weekend before publication.
This is our observed review time, not a promise about future Google Play reviews. Review duration can vary significantly between apps and submissions. The useful lesson was to avoid repeatedly cancelling and resubmitting a review unless a change was genuinely necessary.
The result
The app successfully made it through the Google Play publishing process and became discoverable through Google Play's testing distribution. We verified the listing from a separate phone rather than relying only on Play Console's status, which gave us confidence that the published track had propagated to the storefront.
More importantly, the final architecture stayed simple: Shopify continued to handle the commerce backend, Customer Accounts handled authentication, Checkout handled payment and order creation, and the Android app focused on giving Ritu Fashions customers a dedicated mobile shopping experience.
The journey also showed why app publishing is part of product engineering rather than an afterthought. The finished result depended on the combination of a working commerce integration, reliable mobile UX, platform-specific testing, organization verification, and a release process that could be verified from the customer's point of view.
A mobile app launch is a product + platform process.
Building the UI is only the beginning. Account verification, authentication, payments, testing, reviewer access, store metadata, and release management are all part of delivering a production-ready app.