Mobile app development timelines are one of the most consistently misquoted numbers in our industry. We've seen "8 weeks to App Store" promises and "12 month" estimates for projects that ship in three. After running 30+ production app launches across iOS, Android and cross-platform stacks, here's the breakdown we actually use when scoping a brief.
The four real cost centres
Most app timelines are dominated by four phases, not by the lines of code:
- Discovery and architecture — turning a brief into a buildable spec.
- Design — UX flows, design system, motion, edge states.
- Engineering — feature implementation, integrations, QA.
- Store readiness — App Store Connect, Play Console, ASO, review process.
Skipping or compressing any of these is where most "delayed" projects originate. The engineering phase rarely slips on its own — it slips because discovery wasn't deep enough or the design system wasn't ready.
Realistic timeline brackets
Minimum-viable apps (MVP, 4–8 weeks)
Tight scope, no auth complexity, one platform first, no third-party integrations beyond analytics and crash reporting. Examples: a content app with a hand-curated feed, a single-purpose utility, a marketing companion app.
What you trade off: limited animation polish, no admin panel, manual app store metadata, no push notification segmentation. You can ship a usable v1 — but you'll likely rewrite half of it in the next quarter.
Production-ready apps (8–16 weeks)
Auth (email, Apple, Google), one or two integrations (payments, analytics, push), a real design system, and CI/CD pipelines from day one. Most B2C apps we ship live here.
Common scope at this level:
- Full sign-up + onboarding flow
- 5–10 main screens with motion and transitions
- Real-time data sync via WebSockets or polling
- In-app purchases or subscriptions (StoreKit, Google Play Billing, RevenueCat)
- Analytics + crash reporting + remote config
Platform-grade apps (16–28 weeks)
When the app is the product, not a companion. Multi-tenant data, offline-first architecture, complex permissions, native modules, large content libraries.
Examples we've shipped: a B2B logistics dispatch app with real-time route updates, a healthtech wellness platform with personalised content engines, a marketplace where providers and consumers use different app variants.
Native or cross-platform?
This decision adds or removes 20–40% of the engineering time depending on which way you go.
Native (Swift + Kotlin) is the right choice when:
- You're shipping immersive UX (AR, custom camera, complex animations)
- Platform-specific features matter (Live Activities, Widgets, Wear OS)
- The app is the product, not a companion
Cross-platform (Flutter, React Native) is the right choice when:
- You need to launch on iOS and Android simultaneously
- Your team can support one stack better than two
- 95% of the UX is the same across platforms
For most B2C apps in 2026, Flutter and React Native are mature enough that the performance gap is invisible to end users.
What actually causes delays
After 30+ launches, the slip-pattern is consistent. In order of frequency:
- Scope creep after design freeze — "can we just add..." in week 6 is the classic.
- Third-party API instability — sandbox != production for payment, identity, and shipping providers.
- App Store review surprises — privacy policy gaps, IAP rules, App Tracking Transparency.
- Backend not ready — mobile is downstream of API. If the API isn't versioned and stable, mobile becomes a permanent regression machine.
- Design rework after first usability test — the right time to test is week 2, not week 10.
Budget brackets that match these timelines
For senior teams shipping production-grade apps in 2026:
- MVP, 4–8 weeks → €25K–€60K
- Production-ready, 8–16 weeks → €60K–€150K
- Platform-grade, 16–28 weeks → €150K–€400K
These numbers assume senior engineers and designers throughout. Junior teams cost less per hour but typically take 1.5–2× longer and produce more technical debt — the total cost of ownership is rarely lower.
How we scope at runIT
Before any timeline commitment, we run a one-week discovery sprint:
- Day 1–2: stakeholder workshops, technical audit if you have an existing app
- Day 3–4: information architecture, user flows, technical risk register
- Day 5: scoped backlog, sprint plan, fixed-price proposal
The output is a Linear board with epics, acceptance criteria and dates we'll commit to. Everything that lands on production maps back to an item you've approved.
If you're starting a mobile project and want a sanity check on the timeline you've been quoted, tell us about it — we'll send you a free second-opinion brief within 48 hours.