App or mini program rejected in review: fix the code or supply the documents first?
Start with the conclusion
After a rejection, the first thing to do is not to ship a new build but to classify the rejection text. Most rejections fall into one of four layers: entity and qualifications, privacy and permissions, content and transaction rules, review reachability. Only the second and third are mainly solved by changing code; the first layer is solved by supplying documents, and the fourth usually just needs a path the reviewer can actually walk. Misjudge the layer and you get the familiar pattern: three releases later, the same rejection sentence.
There is a rough but useful dividing line. When the rejection says "unable to", "could not find", "please provide" or "insufficient explanation", treat it as documents and reachability first. When it says "collects", "requires users to", "undeclared" or "does not possess", treat it as product design. The former means changing documents and entry points, the latter means changing code, and the cost differs by an order of magnitude.
This is also why "everything passed our internal testing" is not an effective response: review is not functional testing. It checks something else.
What review actually checks, and why it is not your acceptance test
Three differences explain most rejections.
Review only walks the first screen and the visible paths. The reviewer gets a clean device and a new account, and follows an ordinary user's path from first launch. Your sales demo route, the test account you handed the client and the whitelist you configured in the admin console are invisible to them. Any feature that needs someone's cooperation to be seen effectively does not exist during review.
Review applies platform rules and regulations, not your requirements document. The platform does not care how hard the feature was to build or how urgent the client is; it only decides whether this thing may appear in its distribution channel. Passing requirements acceptance and getting the client's signature are separate conclusions from being allowed to publish.
Rules do not carry across channels. The iOS App Store, the various domestic Android stores and WeChat mini programs each have their own review entity, material requirements and category definitions. A mini program approval does not mean the app will pass; passing one Android store does not mean the next store will not raise new issues.
The conclusion is direct: treat submission as a fourth acceptance line, alongside functional, data and security acceptance, with its own materials, owner and pass criteria. It should not be a "click submit" action tacked onto the end of development.
Locate before you act: four questions that fix the layer
When a rejection arrives, ask four questions in order.
- Is it saying "I could not see it" or "it should not be there"? Not seen is a reachability problem; should not be there is a rule or design problem.
- Does it cite a platform clause or a regulation? A platform clause calls for remediation inside the platform; a regulation points at entity qualifications, which code cannot fix.
- Can it be reproduced reliably? Another account, another OS version, another device: does it still happen? What cannot be reproduced is usually account state or a difference in the review environment.
- Is the fix in code, in documents, or in scope? Scope means leaving this feature out of this submission.
The matching responses look roughly like this:
| Rejection wording | Usual layer | First action | Common misjudgement |
|---|---|---|---|
| Missing filing number or qualification documents, entity inconsistent with the account | Entity and qualifications | Supply documents, clarify entity ownership | Rewriting the bundle ID, switching accounts |
| Login required to browse, permission prompts at first launch, undeclared collection | Privacy and permissions | Change flows and copy, redo permission timing | Adding one sentence to the privacy policy |
| Digital content without in-app purchase, incentivised sharing, unmoderated UGC | Content and transaction rules | Change the business model or cut the feature | Repeated appeals |
| Reviewer cannot find the entry, demo account expired, feature depends on hardware | Review reachability | Provide accounts, screen recordings, written paths | Redesigning the interface |
The "common misjudgement" column is where real cost is wasted: once the layer is wrong, every following step is wasted work.
Layer one: entity and qualifications, most often mistaken for a technical problem
The signature of this layer is that nothing is technically wrong, and yet you cannot get in.
Both apps and mini programs require filing. The basis is the Notice on Carrying Out Filing for Mobile Internet Applications (MIIT No. 105 [2023]) issued by the Ministry of Industry and Information Technology in July 2023. The notice states that APP providers offering internet information services within China must complete filing, that those who have not completed filing may not provide APP internet information services, and it set a catch-up filing schedule for apps that were already operating before the notice. Mini programs are covered as a distribution form as well; WeChat's mini program filing guide lists the corresponding legal basis and provides the filing entry and process on the WeChat Official Accounts Platform.
One recurring misunderstanding: an ICP filing for your website does not replace filing for a mini program or an app. The filing objects differ: one is a domain and a website, the other is a specific application. Your corporate site having been filed long ago does not mean a mini program can be submitted directly.
The developer account entity must match your qualifications. Submitting a business with a personal account, a business licence entity that differs from the account entity, or a software copyright holder that does not match the submitting entity will all trigger requests for explanation. Changing entity mid-project is the most expensive version of this problem, because it drags certificates, bundle IDs, historical builds and data ownership along. Decide entity ownership at contract stage, not at submission.
Some industries require prior approval. The Measures for the Administration of Internet Information Services set prior approval requirements for internet information services in news, publishing, education, healthcare, pharmaceuticals and medical devices. Whether your service falls in scope, who applies and which documents are required must be confirmed item by item with the local communications administration and the platform's category notes. "A peer did it this way" is not a basis for inference.
The trade-off at this layer is clear: qualifications are a time cost, not a technical cost. Filing and approval take weeks or longer, during which you can develop, run internal testing and deliver for acceptance as usual, but you cannot go live to the public. So schedule qualification work to start in parallel in the first half of the project rather than after the build is done. Many projects are not blocked by development but by discovering, after development, that the filing was never submitted.
Layer two: privacy and permissions, fixed in code rather than copy
This layer attracts the most rejections and is the most often mishandled: many teams reach first for "add a line to the privacy policy", while review looks at actual behaviour.
Concrete checkpoints:
Request permissions at the moment of use, and allow refusal. Prompting for camera, location and contacts back to back on the first screen is a textbook high-risk pattern. Request each permission when the corresponding feature is triggered, explain the purpose, and keep the parts of the product that do not need that permission usable after a refusal, in other words provide a degraded path.
The privacy policy must open inside the app and also be filled in the store console. Both are required, and the content must match actual collection behaviour. Which data you collect, for what purpose and whether it is shared with third parties are not boilerplate; review checks them against the real features.
Declare third-party SDKs and external services truthfully. Analytics, push, maps, payments and increasingly third-party AI services all carry user data out of your app. Sending data to a third party while omitting it from the declaration is an explicit rejection point. Clauses 5.1.1 (data collection and storage) and 5.1.2 (data use and sharing) of the Apple Review Guidelines address exactly this, and developer communities report many rejections for undeclared third-party data processing.
If you have accounts, you must have account deletion. A registration entry without a deletion entry has been a steady rejection reason in recent years. The deletion path must be findable and completable inside the app; "contact support and we will handle it" is usually not accepted.
Do not force login without account-based features. If the core functionality does not depend on an account, mandatory registration will be asked to become skippable. This is especially common for utility and showcase apps.
Be able to justify minimum necessary collection. A booking feature does not need contacts; a display page does not need precise location. Extra permissions add no capability, only risk.
In practice, turn this layer into a table and walk it on a real device item by item: permission name, trigger timing, prompt copy, usable path after refusal, corresponding privacy policy clause and corresponding third-party SDK. That table is both the remediation list and the regression checklist for every future release.
Layer three: content and transaction rules, where the business model has to change
This layer is the most expensive, because it often requires changing the product itself rather than fixing a flow.
Payment paths for digital content and virtual services are constrained. Selling digital content, subscriptions and virtual items on iOS generally requires in-app purchase, and bypassing it is rejected; physical goods and offline service bookings generally fall outside this scope. The boundary should follow the latest wording of the official guidelines, because platforms adjust their positions. This affects membership, courses, paid content and AI credit packs most, and it should be settled at design stage: changing it later means rebuilding the payment chain.
Incentivised sharing and reward-based viral loops are explicitly limited. Rewards in exchange for sharing, or gating features behind a mandatory share, are rejection points on multiple channels.
User-generated content requires moderation and reporting. Posts, comments, avatars and nicknames all need content moderation, a reporting entry and a handling process. This is not an "add it later" item; it is a precondition for publishing.
Content wording in certain industries is bound by qualifications. Healthcare, financial advice and education content involves qualifications, phrasing and disclaimers; wording beyond the licensed business scope will be judged as the entity lacking the relevant qualification.
The principle for this layer: if the business model itself conflicts with channel rules, changing the product is cheaper than repeated appeals. Appeals only apply when a rule has been misapplied, that is, the feature genuinely falls outside that clause and you have the material to prove it. When the rule applies correctly and you do not comply, an appeal will not change the outcome; it only burns time.
Layer four: review reachability, the cheapest and most overlooked
This layer has almost nothing to do with code quality, yet it is a frequent cause of "three releases, the same rejection".
Demo accounts must actually work. They must log in, include at least one account per role, keep the same password and data during the review window, and not depend on SMS codes (the reviewer does not have your phone). If a code is mandatory, provide a fixed test code or explain the handling in the review notes.
A hidden entry does not exist. A feature behind an admin switch, behind a whitelist, behind the corporate network or requiring specific hardware is invisible to the reviewer. The usual outcome is not "approved" but "feature incomplete" or "insufficient information".
Store screenshots and the first screen must match the actual product. Showing an interface in the listing that cannot be found in the app is an explicit misleading issue.
Features that depend on hardware need an alternative path. Bluetooth devices, QR scanning and location check-in have no matching conditions in the review environment. Provide a demo mode, or attach a short screen recording in the review notes showing how the main flow can be verified without the hardware.
Release notes must state what changed. Especially after a previous rejection, mapping the notes item by item to the remediation measurably reduces back-and-forth.
One boundary deserves to be explicit here: do not use an "in review" switch to hide unfinished modules. It may get you through once, but it stacks two risks: being judged as having incomplete core functionality, and, after launch, flipping the switch effectively bypassing review, which can lead to removal if re-inspected. The right move is to narrow the scope of this submission to the core paths that run end to end, and ship the rest in the next version. This should also be the same thing as your publicly committed first-release scope.
Cross-channel and overseas publishing: do not reuse the previous set of materials
The same feature set needs different materials on different channels, and this is more obvious overseas.
Category, qualification and privacy requirements for domestic Android stores are set by each platform; passing one store does not mean the next will not raise new issues, so prepare to the strictest channel and the rest can usually reuse those materials. For an overseas version, beyond functional localisation you must separately handle privacy declaration forms, data collection disclosures, account deletion paths and target-market compliance requirements. These are not the same documents you wrote for domestic users, and the rework is routinely underestimated.
In practice, lay out a "channel x material" matrix, one row per channel, with columns for qualification documents, privacy policy, data declarations, demo accounts and review-note templates. Fill the matrix before submitting; it is faster than trying channel by channel.
Treat rejection response as a process, not an incident
Rejections are normal; the problem is treating each one as an emergency. Fix the following routine:
Build a submission pack. Entity qualifications and filing information, demo accounts with role descriptions, a screen recording of the main flow, a permission and third-party SDK inventory, the privacy policy link, category and industry qualifications, and change notes for this version. Reuse the pack for every release and update only what changed.
After a rejection, decompose first and change nothing. Split the rejection text into three columns sentence by sentence: what the platform asserts, what evidence you have, what action follows. You will usually find that one sentence mixes two problems, and fixing only one obviously will not pass.
Change one layer at a time. Changing code, copy and screenshots simultaneously means you cannot tell which change did the work, and you will repeat the mistake next release. Unless the rejection explicitly lists several items, fix the most critical one and explain that fix in your reply.
Make replies specific to a path. An effective reply reads: we changed X; on page A tap B to reach C; verify with account D. A vague "related issues have been fixed" is effectively no reply.
Keep a rejection log. Channel, date, version, clause, reason, remediation and outcome. After two versions it becomes the team's own rulebook, more accurate than any generic checklist, because it records where this specific product actually gets stuck.
By scenario: three types of project have different priorities
A project validating a business from zero to one. Do the mini program first; do not go multi-platform at launch. Filing, categories and review routing for mini programs are relatively concentrated and cheap to iterate; add the app once the business model is stable, so you are not maintaining three sets of review materials while requirements are still changing. The precondition is that the business suits a mini program: hardware, background execution or complex offline capability do not.
An existing system that needs a client app. Confirm two things first: whether entity qualifications are complete, and whether the compliance boundaries of existing data are clear. Whether employee data, customer data and historical orders may appear on mobile, and with what visibility, must be decided at prototype stage. Fixing the data permission model after review raises the issue is expensive.
An existing app adding AI features. Three things need early judgement: whether user data is sent to third-party model services, whether generated content needs moderation, and whether AI output touches professional-advice wording. These determine whether you need declaration materials, a content moderation mechanism or product wording. At design stage that is one review; before submission it is rework.
Who is responsible for what: client, us and the platform
Being clear about this is far more useful than promising guaranteed approval.
The client is responsible for: the authenticity and validity of entity qualifications, ownership and real-name information of the developer account, industry qualifications and business scope, and the legality of the business rules themselves. Only the entity can do these, and no external party can promise them on your behalf.
We are responsible for: technical remediation (permission timing, login and deletion flows, degraded paths, data declarations consistent with the code), material preparation (permission and SDK inventory, category and qualification mapping, change notes), assembling the submission pack, technical explanations during review correspondence, and, with the client's authorisation, submitting and following up on their behalf.
The platform and regulators are responsible for: review outcomes, review duration and rule changes. None of that is within any service provider's control, which is why we do not promise approval first time or a specific review timeline. What we can promise is filling foreseeable material gaps before submission, and locating rejections by process instead of blindly resubmitting.
Boilingwater builds custom software and digital systems, covering apps and mini programs, enterprise management systems, AI applications, IoT and overseas projects; deliverables include source code, data, documentation and third-party accounts. Accounts belonging to the client matters especially at submission: entity, accounts and qualifications stay under the client's name, so changing providers later does not affect ownership of the app. Projects that need risk assessment before submission, or compliance constraints considered at design stage, can start from this step.
Six things you can do next
- List the channels for this launch and the entity behind each. One app maps to one entity; parallel entities must be separated from the start.
- Check filing status. Check app and mini program separately; a website ICP filing does not count. Verify on official entries, not on third-party lookup results.
- Build the permission and third-party SDK inventory, writing purpose, trigger timing and usable path after refusal for each item. The same table serves as development task list and review material.
- Assemble the submission pack, complete with demo accounts, recordings, qualifications and change notes the first time.
- Submit only core paths that run end to end, leaving unfinished modules out of this version rather than disguising them behind a switch.
- Keep a rejection log, recording clause and remediation each time. After two versions it becomes the checklist that fits your product best.
Additional Q&A
After several rejections, should we switch the developer account?
Usually not. Changing the account entity brings knock-on problems with qualifications, certificates, historical builds and data ownership, while the rejection reason does not disappear because the account changed. Entity-level adjustment is only worth considering when the entity information itself is wrong or the account has violation records.
The filing is not approved yet. Can we start development?
Yes: develop, run internal testing, deliver for acceptance. You cannot go live to the public. That is why qualification work should run in parallel from project start rather than after development finishes.
The mini program passed review. Can the app go straight up?
No. Review entity, material requirements, category definitions and payment rules all differ. Mini program experience can be reused; its conclusions cannot.
Sources
The legal and platform-rule basis for the judgements in this article is listed below. Clause numbers and wording should follow the latest official pages; all were checked on 2026-11-16:
- Ministry of Industry and Information Technology, Notice on Carrying Out Filing for Mobile Internet Applications (MIIT No. 105 [2023]), gov.cn: https://www.gov.cn/zhengce/zhengceku/202308/content_6897341.htm
- Same notice, MIIT website: https://www.miit.gov.cn/zwgk/zcwj/wjfb/tz/art/2023/art_920db564162e4312916a01bed6540ad8.html
- WeChat Open Documentation, Mini Program Filing Guide, including legal basis, entry points and process: https://developers.weixin.qq.com/miniprogram/product/record/record_guidelines.html
- Apple App Store Review Guidelines (including 5.1.1 Data Collection and Storage and 5.1.2 Data Use and Sharing): https://developer.apple.com/app-store/review/guidelines/
Recommendations on remediation order, responsibility split and project scheduling reflect our judgement from delivering custom projects; they are methodology, not platform rules. Specific projects must confirm each item against the relevant channel and local requirements.