Skip to content
Velloreth
Projects 6 min read

Lessons from Shipping My First Mobile App

First-person account of shipping a first mobile app: framework choice, app store rejections, review times, crashes, updates, and what I would do differently.

By

Writing code for a phone feels like writing code anywhere until you try to put it on a store. My first mobile app took about three months of part-time work to build, and roughly the same again to ship. Most of that second stretch had nothing to do with the code.

This is the honest account: what I chose, what broke, what the stores rejected, and what I would do differently next time.

The app and the stack

The app was a personal tool: a habit tracker with daily check-ins, a streak counter, and a weekly summary. Simple enough that I could finish it, complex enough to need local storage, background notifications, and a settings screen.

I chose React Native because I already knew JavaScript and because one codebase deploys to both the Apple App Store and Google Play. Building native twice — Swift for iOS, Kotlin for Android — would have doubled the work for a solo developer with no deadline. The trade-off was real: I hit platform-specific bugs with the camera picker on iOS and the notification channel on Android, and I spent evenings debugging them. I would make the same choice again, but I would budget time for those edge cases up front.

State management was React Context plus local file storage. I did not add a backend. Version one stored everything on the device, which meant no login screen, no sync, and no server bills. It also meant no way to recover data if the user deleted the app. I was explicit about that in the onboarding.

Development versus reality

The emulator was friendly. It launched fast, hot reloading worked, and the app looked correct. Real devices were not friendly.

On an iPhone SE with a small screen, my form fields sat behind the keyboard. On a budget Android phone, the animation I thought was smooth dropped frames. Battery drain from a polling timer I forgot to pause showed up in a single evening of testing. None of these appeared on my laptop emulator.

I bought one used iPhone and one used Android phone and tested on them weekly. That single habit found more bugs than all my emulator testing combined. I also watched people use the app while sitting next to them — they tapped things I never expected and ignored the feature I spent two weeks on.

App Store Connect and Google Play Console

Creating the accounts costs money: $99 per year for Apple, a one-time $25 fee for Google. Both require identity verification and take days to approve, so start the accounts before the app is ready, not after.

The store listings are their own project:

  • App name and subtitle
  • Icon at ten different sizes
  • Screenshots for each device size (iPhone 6.5”, iPad, Pixel 7, foldables)
  • Privacy policy URL — required by both stores even if you collect nothing
  • Category, keywords, age rating

I wrote the privacy policy myself. It said the app stores data locally, does not send it anywhere, and lists what permissions it requests and why. Both stores accepted it, but Apple asked me to clarify why the app wanted notifications. That was a one-day back-and-forth.

Rejections

My first submission to the App Store was rejected. The reason was not a crash or a bug. It was “placeholder content” — a screenshot still contained lorem ipsum text, and one screen of the app said “Coming soon” because I had not finished the weekly summary view.

I removed the placeholder, finished the view, replaced the screenshots, and resubmitted. The second review passed.

Google Play rejected an early build because I requested the notification permission without explaining its purpose in the store listing. I added a sentence to the description — “Notifications remind you to check in each day” — and resubmitted. Approved the next day.

Rejections are normal. Neither store expects a perfect first submission. What matters is reading the rejection note, fixing the exact thing they named, and not assuming your code is at fault when it usually is not.

Review times

Apple’s review for a new app took about three business days in my experience. Updates were faster, roughly one to two days. Google Play’s initial review was quicker — under a day — but both platforms can delay an app that uses sensitive permissions, payment, or health data for additional review. I planned releases assuming a week of review buffer and never missed a self-imposed date because of it.

TestFlight and internal testing

Before either store review, I distributed builds to five friends through Apple TestFlight and Google Play internal testing. This is where the real issues surfaced:

  • The app crashed on launch for one tester because their phone was in low-power mode and a background task failed.
  • Date formatting showed the wrong weekday because I hardcoded the locale instead of reading the device setting.
  • The onboarding screen was unskippable, and testers hated it after the second launch.

I fixed all three before submitting to the stores. TestFlight builds expire after 90 days, so I uploaded a fresh build every few weeks even when nothing changed, just to keep the testing channel open.

Crashes and updates

The first public version had one crash: opening the settings screen on Android 13 without granting notification permission threw an uncaught error. I caught it within hours via a crash report, patched it, and submitted an update.

There is no instant rollback on either store. A bad release stays live until the fixed version clears review. I learned to ship small updates rather than big ones, so each review was short and the risk was contained. I also added a simple in-app version check so I could message users directly if a release broke something fundamental.

Versioning and what I would change

I used semantic versioning: 1.0.0 for launch, 1.0.1 for the crash fix. Build numbers incremented with every submission so the stores could tell them apart.

If I rebuilt it today:

  1. Backend later, local first. Keep everything on the device for version one. Sync is a feature, not a requirement.
  2. Screenshots and metadata first. Write the store listing in parallel with development, not after the build is finished.
  3. Real devices weekly. One afternoon on physical hardware finds more issues than a month on emulators.
  4. Skippable onboarding. Never force a user through an introduction twice.
  5. Crash reporting from day one. I added it after the first crash. It should have been in the first build.

The app is still live. It has a few dozen users, most of them people I know, and it does the one thing it was built to do. Shipping it taught me that the code is the easy part — getting it onto a phone in someone’s hand is the actual product.

Frequently asked questions

How long does app store review take?
It varies. Apple's App Store review typically takes a few days but can stretch longer for new apps or apps using sensitive permissions. Google Play is often faster for initial publication, sometimes within hours, though both platforms can delay apps that need additional review. Neither timeline is guaranteed.
Cross-platform or native for a first app?
Cross-platform (React Native or Flutter) ships to both stores from one codebase, which matters when you are a solo developer. Native gives you full platform access but means building everything twice. I chose cross-platform and accepted the occasional platform-specific workaround.
What gets first-time apps rejected?
Common reasons: placeholder text in screenshots, missing privacy policy, asking for permissions without explaining why, and functionality that duplicates a built-in app. Most are listing issues, not code issues, and are fixable without a rebuild.
Can you fix a bad release quickly?
You can submit an update immediately, but it must go through review again, so there is no instant rollback. Google Play offers staged rollouts to limit blast radius; Apple's equivalent is phased release. Test thoroughly before submitting.