The 58-point
launch checklist.
The exact list I run before, during, and after every app launch. Discovery, design, build, and ship — distilled from 20+ shipped projects. Tap to check off as you go.
Discover.
Before a single line of code. The cheapest changes happen here — the most expensive omissions get caught here too.
10 items
- 01
Define the one user
Pick the most narrow user persona. If you can describe them in a sentence, you've earned the right to start.
- 02
Write the elevator pitch
One paragraph: what it is, who it serves, why now. If you can't, you're not ready.
- 03
Identify the unfair advantage
What's the one thing only you can ship? Build around that.
- 04
List 'must' vs 'should' vs 'could' features
MoSCoW prioritisation. Most teams over-promise on must-haves.
- 05
Decide the success metric
One number you'll watch from day one. Engagement, retention, conversion — pick one.
- 06
Sketch the happy path
End-to-end user journey on paper. Three to five screens, max.
- 07
Check legal, IP, compliance early
GDPR, HIPAA, PCI-DSS, your local equivalent. Costly to retrofit.
- 08
Talk to 5 users
Five conversations beat fifty assumptions. Note what surprised you.
- 09
Set the budget honestly
Including 20% contingency. Including post-launch operating costs.
- 10
Decide the launch date constraint
Real or imagined? Deadlines drive scope cuts — they should.
Design.
Architect for the second release. The first release is just an excuse to learn what the second one needs.
12 items
- 01
Pick the platforms
iOS, Android, web — and the priority order. Don't promise universal at v1.
- 02
Choose the stack with intent
Flutter, native, Next.js — match the stack to the team you'll have, not the team you wish for.
- 03
Lock the state-management pattern
BLoC, Riverpod, Redux. Pick one. Migrate everything to it before adding features.
- 04
Design system or component library
Even three components beats inconsistent styling. Extend it as you ship.
- 05
Wireframe the top 5 screens
Fidelity comes later. Hierarchy and flow come first.
- 06
Plan navigation and information architecture
Tab bar? Drawer? Stack? Match the user's mental model, not what looks novel.
- 07
Define the data model
Entities, relationships, ownership. Document it. Future-you will thank you.
- 08
Spec the API contract
OpenAPI, tRPC, GraphQL schema. Frontend and backend should never argue over endpoints.
- 09
Plan offline behaviour
Mobile users lose connectivity. Decide what they can do without it.
- 10
Decide auth strategy
Email + password, social, passkeys, magic links. Pick before building anything else.
- 11
Sketch a real-world error state
Most apps treat errors as afterthoughts. Yours shouldn't.
- 12
Set performance budgets
Time to interactive, hero image weight, API latency. Numbers — not adjectives.
Build.
Ship in surgical increments. Tests, instrumentation, and reviews baked in — never bolted on.
16 items
- 01
Repo + folder structure decided
Monorepo or polyrepo. Feature-folders or layer-folders. Pick early, document, move on.
- 02
Linter + formatter on save
ESLint, Prettier, dart format. Don't argue about tabs in code review.
- 03
Pre-commit hooks
Husky + lint-staged. Block bad commits before they're pushed.
- 04
CI pipeline running on every PR
Lint, typecheck, test, build. If it's red, nothing merges.
- 05
Branch naming and PR template
feat/, fix/, chore/. PR template with description, screenshots, test plan.
- 06
Unit tests for business rules
Pure functions, domain logic. No frameworks needed. Aim 70%+.
- 07
Widget / component tests for critical UI
Login, payment, checkout. The five flows nobody can break.
- 08
Integration test for the happy path
End-to-end. The one test that catches everything.
- 09
Crash reporting wired up
Crashlytics, Sentry. Free, fifteen minutes to set up, saves weekends.
- 10
Analytics events on every state change
Page views, feature usage, errors. If it isn't measured, it didn't ship.
- 11
Feature flags from day one
Even when you don't 'need' them. Future-you will. Remote config or LaunchDarkly.
- 12
Deep linking + universal links
Web → app handoff. Marketing campaigns will demand it.
- 13
Accessibility audit on the main flow
VoiceOver, TalkBack, keyboard nav. WCAG AA minimum.
- 14
Localisation hooks even if you ship one language
Cheap to add now, expensive to retrofit.
- 15
Secure secret management
No keys in code. Environment variables or secret managers.
- 16
Database migrations versioned
Liquibase, Flyway, your equivalent. No more 'works on my machine' schemas.
Optimise & ship.
Measure, refine, release. Performance is a feature. Stability is a feature. Velocity is the absence of fear.
20 items
- 01
Run a real device performance test
Mid-range Android, three years old. If it's smooth there, it's smooth everywhere.
- 02
Bundle / app size audit
Strip unused assets, tree-shake aggressively. Every MB matters on emerging-market data.
- 03
Cold start under 2 seconds
On low-end Android. Profile, fix, repeat.
- 04
Image optimisation pipeline
WebP, AVIF, responsive sizes. Cloudinary, ImageKit, Vercel Image.
- 05
Database indexes on hot queries
Profile, find the N+1, add the index.
- 06
API response caching where it makes sense
Stale-while-revalidate, ETag. Don't refetch what hasn't changed.
- 07
App store / Play Store assets ready
Screenshots, descriptions, keywords, age rating, privacy policy.
- 08
Privacy policy + terms of service
Both required. Generate via Termly or write properly with a lawyer.
- 09
Beta release with 20 testers
TestFlight, internal testing track. Fix what they find before public release.
- 10
Staged rollout plan
1% → 10% → 50% → 100%. Watch crash-free percentage at each step.
- 11
Rollback playbook
Document the emergency stop. Test it before you need it.
- 12
Post-launch monitoring dashboard
Crash-free sessions, DAU/MAU, error rate. Watch it for the first 72 hours.
- 13
Customer support channel
Email, chat, in-app feedback. Reply within 24 hours during the launch window.
- 14
Marketing site + launch announcement
One landing page, one Twitter thread, one Product Hunt post. Don't over-engineer this.
- 15
Retention email or push sequence
Day 1, 3, 7, 30. Thoughtful — not spammy.
- 16
Onboarding analytics funnel
Where do users drop off? That's where v1.1 begins.
- 17
Schedule the post-mortem
Two weeks after launch. What did we learn — what would we do differently — what's next?
- 18
Plan the maintenance budget
15–20% of build cost annually. Bug fixes, OS updates, dependency upgrades.
- 19
Backup strategy for production data
Tested. The first time you restore from backup should not be in a real incident.
- 20
Write the runbook
What to do at 3am when production is down. Who to call. What to check first.