The app is built, testing is done, and it feels like all that's left is to hit "Publish." In reality, getting an app into the stores is a separate stage with its own requirements: a developer account, store listing assets, a privacy policy, data disclosure forms, and a review process that can send your build back with notes.
Here's how publishing on the App Store and Google Play actually works: whose account the app should live under, what to prepare in advance, why builds most often get rejected, and how to ship updates without risk. It's what we go through on every mobile app project, and something worth agreeing on with your development agency before work even starts.
The developer account: why it belongs to the client
In each store, an app belongs to a developer account. Everything is tied to that account: the store listing, reviews, ratings, install stats, signing keys and certificates, and, if the app sells anything, payouts. So the question of whose name the app ships under is not a formality.
Here's a common scenario. An agency publishes a client's app under its own account "to save time." A couple of years later the company decides to switch vendors or bring development in-house, and discovers the app doesn't technically belong to them. Transfers between accounts are possible, but they're a separate procedure with its own conditions. In the worst case, the app has to be released from scratch, losing its reviews and its search ranking in the store.
Our approach is simple: the developer account is registered to the client's company, and the development team gets access with the permissions it needs. App Store Connect and Google Play Console both let you invite users and limit their roles, so the owner stays in control while the vendor ships releases.
What to prepare before publishing
The store listing is your app's landing page. It's where users decide whether to install, and where the reviewer checks that the description matches what they'll find inside. It's best to collect these assets as the project goes, not on the last day.
Store listing assets
- Icon. Recognizable at small sizes, with no tiny text. Size and format requirements differ between stores, and on Android the icon is also cropped to whatever shape the device uses.
- Screenshots. Real app screens in the required device sizes. The first two or three screenshots should explain the main benefit, because that's what people see in search results.
- Name, short and full description. Written both for in-store search and for a real person: what the app does and why it's useful. Promising features the app doesn't have is not allowed.
- Category, age rating, support contacts. The age rating comes from a questionnaire in the console, and the contact details need to actually work.
The icon and screenshots are easiest to produce alongside the app's design: by then the visual style, screens and key flows already exist.
Privacy policy and data
Almost any app that knows something about its users needs a privacy policy: sign-up, phone number, location, analytics. The link goes into the store console and inside the app itself. On top of that, the App Store and Google Play ask you to fill out forms on what data the app collects and why. Your answers have to match what the code really does, including third-party analytics and advertising SDKs.
The policy also has to comply with GDPR and any other data protection law that applies to your users. Have a lawyer review the text, and let the developers tell you which data and services are actually involved.
Access for the reviewer
If the app can't be used without logging in, the reviewer needs a test account: a username, a password and a note on how to proceed. If login works via SMS, you'll need a test number with a fixed code. If some features are only available to certain users, such as employees or customers with a contract, provide an account with those permissions and short instructions. Without this, the build will almost certainly come back with a request for access.
App review: why apps get rejected
Each store checks an app before it goes live: manually, automatically, or a mix of both. The specific rules at Apple and Google differ and get updated regularly, but the reasons for rejection tend to repeat.
- Crashes and obvious bugs. The app closes on launch, on a particular OS version or after login. The reviewer tests on their own devices, not the ones sitting on your team's desks.
- Incomplete functionality. "Coming soon" placeholders, empty sections, test copy, buttons that do nothing. Apps that add little beyond a website in a wrapper get rejected too.
- Unexplained permissions. The app asks for camera, contacts or location access without saying why, or asks for it where the feature isn't needed.
- No privacy policy, or one that doesn't match the data disclosure form and the app's real behavior.
- The reviewer couldn't log in. No test account, the SMS code never arrives, or the account is locked.
- The listing doesn't match the app. Screenshots from an old design, promises of features that don't exist, someone else's trademarks used without rights.
- Payments that bypass store rules. For digital goods and subscriptions, stores generally require their own payment systems, and breaking this rule is a common reason for rejection.
Most rejections aren't a dispute over the rules. They're a sign the preparation wasn't finished.
A rejection isn't a disaster. The reviewer's response usually names the guideline and where the problem was found. You fix it, reply to the reviewer in the console if needed, and resubmit. But every round pushes the release back, so it's cheaper to pass the first time.
App Store and Google Play: what differs
The two stores follow the same logic, but the details matter when you plan a release. Here's how we look at them on projects, without promises that depend on the platforms' own decisions.
Google Play
Google Play is the default store on most Android devices. Publishing goes through Play Console: you register an account, create the listing, upload a build and go through review. The logic is the same as in any store: listing assets, a description, an age rating, a privacy policy and access details for review.
If the app sells something inside itself or relies on platform services such as push notifications, decide early how those features will work on each platform. Android and iOS use different SDKs for payments and push, and sometimes separate app variants are built with different services connected.
App Store
The App Store is the main way to install an app on an iPhone. Apple's review tends to be stricter about design completeness, payments for digital content and how permissions are requested, and the rules change from year to year. So we don't promise in advance how review will go; we check the current guidelines before the project starts.
The choice of stores is also tied to the choice of technology. A PWA, for example, installs from the browser and never goes through store review at all, while a native or cross-platform app is published in each store separately.
How to publish an app on the App Store and Google Play: step by step
The consoles look different, but the overall release sequence is the same.
- Developer account. The company registers accounts in the stores it needs under its own legal entity and gives the development team access.
- App record. The app entry is created: name, bundle ID, category, age rating, data disclosure forms.
- Listing assets. The icon, screenshots and description are uploaded, along with links to the privacy policy and support page.
- Test build. The app is signed and uploaded to a test track: TestFlight in App Store Connect, internal or closed testing in Google Play Console. The client's staff install it and run through key scenarios on their own devices.
- Submission for review. The build goes in with test login details and notes for the reviewer if some features aren't obvious.
- Release. Once approved, the app goes live immediately, at a chosen time, or gradually, to a share of users.
Before publishing, the app goes through the same acceptance as any digital product: checking scenarios against the spec, testing on real devices, handing over access to the client.
Staged releases and updates
The first release is only the beginning. After that the app gets updated: fixes, new features, support for new iOS and Android versions. And every update goes through review again.
Staged rollout
Google Play lets you roll out a new version to part of your audience and expand it if everything looks fine. The App Store has phased release for automatic updates. The idea is the same everywhere: a bug in a new version shouldn't reach everyone at once. If crashes spike in the first few days, the rollout is paused and a fix is prepared.
Monitoring and server-side configuration
To know what's happening after release, the app ships with crash reporting and analytics, such as Firebase Crashlytics and Firebase Analytics. Part of the app's behavior is moved to the server: copy, banners, turning features on and off. Then small changes don't require a new build and a new review.
Another useful practice is a forced update mechanism. If an old version can no longer talk to the server, the app asks the user to update instead of quietly breaking.
Pre-submission checklist
Run through this list before you hit "Submit for Review." It's shorter than any store's guidelines, but it covers most of the typical rejections.
- The developer account is registered to the client's company, and the team has access with the right roles.
- The build has been tested on several real devices and OS versions, with no crashes on launch or login.
- The app has no placeholders, test copy or "under construction" sections.
- Every permission request is explained in plain language and appears at the moment the feature is actually needed.
- The privacy policy is published, linked in the console and in the app, and the data disclosure forms match reality.
- If the app has sign-up, users can delete their account the way store rules require.
- The reviewer has a working test login and password or a test phone number.
- The icon, screenshots and description match the current version of the app.
- In-app purchases are set up according to the rules of each store where the app is published.
- Crash reporting and analytics are connected, and the team knows who's watching them in the first days after release.
Store publishing is part of our app work, just like design and development: from registering the account under the client's company to the first updates. If you're looking for an app development company or a digital agency that takes products all the way to users, see how we handle end-to-end mobile app development.
FAQ
Can we publish only on Google Play and skip the App Store?
You can, if your audience is entirely on Android. But Google Play does not reach iPhone users, so an app that all of your customers are supposed to use usually needs an iOS version too, and a decision on how to distribute it.
Who should register the developer account: the client or the agency?
The client's company registers the account under its own legal entity, and the agency gets access with the roles it needs. That way the app, reviews, ratings and signing keys stay with the business owner, even if the vendor changes.
What should we do if the app is rejected in review?
Read the reviewer's response carefully: it usually names the guideline and the screen where the problem was found. Fix the cause, reply to the reviewer in the console with an explanation if needed, and resubmit the build. If the decision looks wrong, both stores have an appeal process.
Does every app update go through review?
Yes. A new version goes through review just like the first one, although usually faster. So plan urgent fixes with some buffer, and move part of the configuration, such as copy and feature flags, to the server so you can change it without a new release.
Can an app that is already published be moved to the company's account?
Usually, yes: both stores have procedures for transferring an app between developer accounts. But each store has its own conditions and limits, so it is simpler to publish under the client's account from day one.




