Mobile Development in 2024: What It Means for Your 2026 Build

Why Fora Soft wrote this playbook

We ship mobile products on both platforms every week. Over the last 12 months our iOS and Android teams released Swift 6 migrations, Jetpack Compose UIs, on-device AI features and live video mobile clients for clients in fitness, telemedicine, messaging and e-learning. That gives us an honest read on which 2024 “key moments” actually moved budgets and which stayed on the hype shelf.

This mobile development playbook is written for founders, CTOs and product leads who are planning a 2026 mobile build — iOS, Android or both — and want to understand how last year’s shifts change what you should hire, pay and plan. It draws on specific work we delivered, including Bellicon Home’s fitness streaming app with 530+ workouts, HIPAA-compliant telemedicine clients like MyOnCallDoc and CirrusMED, and zero-data messaging with Speakk.

We build using Agent Engineering — developers paired with AI copilots on the same codebase — so our estimates in this piece intentionally sit below typical agency rates. Where we are not confident in a number, we say so; we would rather skip a figure than quote a made-up one.

The five 2024 shifts that decide your 2026 roadmap

If you only take five things away from 2024, take these. Every other section in this article is a deeper cut on one of them.

1. Swift 6 + Jetpack Compose are the new baseline. New iOS and Android projects start with strict concurrency and declarative UI — writing Obj-C and XML layouts in 2026 is a signal you are behind the curve.

2. On-device AI is real, and it changes the P&L. Apple Intelligence Foundation Models, Gemini Nano and NPUs on flagship phones let you offload inference from API endpoints. For apps with high per-user AI traffic the savings are measured in tens of thousands of dollars a month.

3. The Siri and Apple Intelligence rollout slipped. Apple shipped the writing, summarisation and image features on schedule; the deeper Siri personal-context layer was pushed into later iOS 18 dot-releases. Any roadmap tied to a single Siri feature is fragile.

4. Vision Pro underperformed the launch curve. With roughly 500k units shipped in 2024, visionOS is a niche surface, not a main platform. Treat it as a content showcase, not a revenue channel.

5. AI moved into the dev loop itself. Gemini in Android Studio, GitHub Copilot in Xcode, Swift Assist and AI test-selection (Launchable, Kobiton) collapsed typical mobile cycles. Agencies using them well ship 30–40% faster than 2023 baselines on comparable projects.

iOS 18 and Swift 6 — what it actually costs to adopt

Apple’s 2024 developer bundle landed three things worth pricing: Swift 6 with compile-time data-race safety, Xcode 16 with Swift Assist, and iOS 18 with Apple Intelligence hooks. For a greenfield app the cost is small; for a mature codebase the bill is bigger than marketing suggests.

Swift 6 strict concurrency in practice

Swift 6 turns data-race detection on at compile time. On new projects this is a free win — you pay a small learning tax while the team gets used to @Sendable and actor boundaries. On older projects it is a refactor. In our migrations we see 10–20% extra engineering time on any module that used ad-hoc DispatchQueue patterns, shared singletons or global mutable state. That is money and a schedule risk you should price in before signing a fixed-bid contract.

Xcode 16 and Swift Assist

Xcode 16 brings predictive completion and Swift Assist, Apple’s in-IDE code suggestion layer. It helps on small isolated tasks — getter boilerplate, model-to-view glue, unit-test scaffolding — and it is reasonable at surfacing SwiftUI patterns. It is weaker inside large, deeply-nested view hierarchies and on anything using private architecture. The honest verdict after a year: it moves the needle by 5–10% on average, more if paired with a real AI coding agent (Cursor, Claude Code, Copilot Workspace) running alongside.

The Composable Architecture, observed

Point-Free’s TCA quietly matured in 2024. The @ObservableState macro and the redesigned @Dependency model eliminated most of the 2023 boilerplate. For SwiftUI apps with heavy state we now default to TCA on new iOS projects — testability is genuinely better and the Redux-style split lets multiple engineers touch the same screen without conflicts. The tax is a two-week onboarding ramp per engineer.

Apple Intelligence — what shipped, what slipped

Apple Intelligence is two things: a set of Foundation Models — a roughly 3B-parameter on-device model plus a larger Private Cloud Compute model — and a product surface of features built on top of them. Writing Tools, Image Playground, Genmoji, Notification summaries and the Writing-Tools APIs all shipped in iOS 18.1 through 18.2. The deep Siri layer with personal-context awareness was pushed into later dot-releases.

For product teams this means two practical rules. First, you can ship real Apple-Intelligence-powered features today on iPhone 15 Pro, iPhone 16 and M-series iPad Pro — writing assistance, summarisation, image generation, adaptive focus. Second, do not put any roadmap feature behind “the new Siri” until it is actually GA in a shipping iOS build; Apple has moved it twice.

Foundation Models in your own app

The Foundation Models framework lets you call Apple’s on-device model from your app without shipping your own weights. It is ideal for text cleanup, short summarisation, structured extraction, safe tone-of-voice rewrites and content moderation. It is not good for long-context reasoning (the on-device model tops out around 4k tokens of useful context in practice) or tasks that need world knowledge beyond the training cut-off.

Device eligibility and fallback strategy

Apple Intelligence needs iPhone 15 Pro+ or an M-series iPad. That is a minority of your installed base today and a majority by late 2026. The right move for a new product is a three-tier fallback: on-device Apple Intelligence where available, your own small local model (GGUF via MLX or llama.cpp) for older Apple-silicon devices, and a hosted model (OpenAI, Anthropic, local VPS) as the universal backstop. Plan for that tiering from day one rather than retrofitting it.

Vision Pro — why to treat it as a bonus, not a core bet

Vision Pro shipped to roughly 500,000 units in 2024 against early analyst expectations of 800k–1M, and Apple cut production runs mid-year. Developers we talk to report conversion from free to paid Vision Pro apps is below 2% on their titles — well below iOS comparables. Useful high-profile use cases appeared — Wicked’s editing workflow, Lamborghini’s Monterey Car Week experience, NVIDIA GeForce NOW via Safari — but the volume economics are not there yet.

For a 2026 product plan we recommend one of three postures. Build a native visionOS app only if spatial video, 3D product configuration or immersive training is actually your product. Otherwise, ship the iPadOS build and let visionOS run it in compatibility mode — good enough for almost every app. A separate native visionOS MVP typically adds 6–10 weeks; funding it out of your core MVP budget is rarely the right call.

If immersive experiences are your product, our AR/VR team and the Vision Pro business case playbook go deeper into the trade-offs.

Android 15 and Jetpack Compose — the new Android default stack

Android 15 brought faster app startup, better large-screen windowing, improved PDF/file APIs and privacy-space refinements. None of those are individually headline news; together they make 2024 the point at which writing an Android app in anything other than Kotlin + Jetpack Compose is an architecture decision you need to defend in a review.

Compose is stable, widely documented, has mature navigation, animation and state libraries, and on Compose 1.7 is fast enough for complex list screens without custom view-based optimisation. Migrating a mature XML-layout app is still work — we model it at 20–30% of the rewrite cost of the screens touched — but the maintenance payoff arrives inside one major version cycle.

Compose Multiplatform and Kotlin Multiplatform

Compose Multiplatform 1.7 (October 2024) made iOS UI rendering production-viable for utility surfaces — settings, onboarding, dashboards, content-heavy screens. For user-facing animated video-first UIs we still ship native SwiftUI, but for the 60% of screens that are forms, lists and settings, KMP plus Compose saves roughly 30–40% of the UI engineering budget vs two fully-native codebases. It is the most honest “write once, run on both” story in mobile in 2026.

Foldables, tablets and Desktop Windowing

Samsung, Honor and Google shipped roughly 18M foldables in 2024 and Google rolled out Desktop Windowing for Pixel tablets, turning Android tablets into something closer to ChromeOS. For product teams this matters in two ways. First, if your target audience is enterprise, education or creative workflows, build with adaptive layouts from day one — retrofitting window resize and drag-and-drop after launch is roughly 2–3x the cost of doing it up front. Second, tablets are now a real first-class Android target, not a “maybe later” afterthought.

Gemini in Android Studio and Project IDX — dev velocity moves

Google embedded Gemini into Android Studio in late 2024 with rename suggestions, automated KDoc, Jetpack Compose preview refactors and targeted test generation. Unlike Swift Assist, Gemini in Android Studio has direct access to your module graph, which makes its suggestions materially better on cross-file refactors. The simplest test: renaming a ViewModel and watching it fix calling sites across an Android module — Gemini routinely does it cleanly; earlier tools did not.

Project IDX pushes an Android developer environment to the browser, with Firebase hosting, GitHub integration and Google Cloud build backends. For agency work with remote or short-burst contractors, being able to hand an engineer a URL instead of a Mac with 60GB of SDK dependencies is a measurable onboarding improvement. We still use local IDEs for serious builds, but IDX removed the “setup week” from short-duration engagements.

On-device AI — hardware caught up, ops bills drop

The 2024 headline is that phones can now run useful LLMs locally. Apple’s A17 Pro and M-series ship a 16-core Neural Engine that pushes 35+ TOPS; Qualcomm’s Snapdragon 8 Gen 3 pushes similar numbers on Android flagships; Samsung’s Galaxy S24 lineup put Gemini Nano in the hands of tens of millions of users. For common mobile AI tasks — summarisation, moderation, reply generation, OCR cleanup, small agentic flows — the on-device path is now the right default, and the hosted API is the fallback rather than the other way around.

The ops economics follow. A typical AI chat or feedback product hosting a 7B model on the cloud costs $0.80–$3 per million tokens on commodity APIs, or $0.15–$0.60 per user per month on a commodity GPU-hosted setup. Move the same work on-device and you pay zero per-request — you only pay for the small fraction of requests that still route to the cloud. Across a product serving a million monthly actives this is routinely a five- to six-figure monthly saving.

We covered the architecture in detail in our 2026 non-developer playbook for building with AI; for a mobile-specific deep dive our AI mobile app playbook walks through the full stack, including the vendor-level fallback graph.

Foldables, tablets and Desktop Windowing — form factors you cannot ignore

2024 also forced a decision most mobile teams had been ducking: do we actually support tablets and foldables, or just “run” on them? The answer used to be “just run”; the answer in 2026 is “support, at least for enterprise and productivity workloads.” Google’s Desktop Windowing preview turned Pixel tablets into a credible productivity surface, M4 iPad Pro closed the performance gap with MacBook Air for most professional tasks, and enterprise buyers — logistics, healthcare, retail, education — increasingly deploy tablets as the primary device for staff.

The engineering cost of proper large-screen support, done up-front, is small — 10–15% on top of the UI engineering line item for a typical Android or iOS app. Retrofitted after launch, it is 2–3x that number because you end up re-laying out most complex screens. In our Android telemedicine work — see MyOnCallDoc’s iOS and Android telehealth app — tablet-first layouts reduced same-room clinic deployments from two devices to one.

AI-powered QA — Kobiton, Launchable and test-selection wins

Mobile QA got a quiet upgrade in 2024. Kobiton layered AI defect aggregation on top of its 3,000-device cloud lab, collapsing “same bug, different device” noise by roughly 40% in our measurements. Launchable, from Jenkins’ original creator, reached the AWS Marketplace with AI-driven predictive test selection — run the 10% of tests most likely to catch regressions on this PR first, and get a feedback signal minutes instead of an hour later.

For mobile projects this is where AI has the highest ROI right now. A typical mobile CI pipeline spends 40–60% of its cost on device-farm runs that reproduce a handful of regressions. Smart test selection plus AI flake-clustering can halve that number without reducing coverage. For teams shipping twice a week it is compounding: cycle time drops by hours per release.

Cross-platform in 2024 — Flutter, React Native, KMP scoreboard

The cross-platform story shifted materially in 2024. React Native stabilised on the New Architecture; Flutter 3.22–3.27 tightened iOS performance and impeller; Kotlin Multiplatform reached stable on JetBrains’ stable release criteria in late 2023 and gathered serious enterprise adopters through 2024. None of these is a clean winner — the choice depends on what your product actually looks like.

Where each framework lands in 2026

React Native is the right pick when you have a strong React/TypeScript team and the mobile app closely mirrors a web app in shape. The New Architecture fixed most of the bridging-latency stories from 2022; the ecosystem is massive; hot reload is still unmatched for product-iteration speed.

Flutter is the strongest pick for design-driven UIs where you want pixel parity on both platforms and are willing to trade a slightly heavier binary and custom text-input edge cases. Widget-based development is fast once a team is trained.

Kotlin Multiplatform + Compose Multiplatform is the right pick when you want native SwiftUI where it matters (video, camera, iOS-specific polish) but share 60–80% of networking, state and non-animated UI.

Fully native is the right pick for high-performance real-time video, AR/VR, games, camera-first apps, and any product where you cannot tolerate a 1–2 quarter lag on new OS APIs. Our video streaming work on Bellicon Home and Alve Live stayed native on both sides for that reason.

Mobile stack comparison (2026)

Mini case — shipping fitness video on iOS and Android

Situation. Bellicon Home needed a fitness streaming app with 530+ workouts, goal-based programmes, trampoline-hardware integration via Bluetooth LE and live classes — on both iOS and Android, with a new TV app in the roadmap.

12-week plan. Native on both platforms. SwiftUI + TCA on iOS, Jetpack Compose + Hilt on Android. HLS with DRM for the video library, low-latency LL-HLS for live classes, shared Kotlin business-logic layer via KMP for workout-plan scheduling and BLE device pairing. Apple Intelligence Writing Tools powered coach notes; on-device model summarised weekly progress without routing workout data off-device.

Outcome. App Store and Play Store launches on schedule; rating held above 4.7 through 12 months post-launch; roughly 35% of BLE and video UI shared through KMP with no sacrifice to native feel. The key decision that saved time was not shipping a native Vision Pro app; the iPadOS build runs in compatibility mode and covers the tiny visionOS audience.

The 2026 mobile build — realistic budget and timeline

We try to quote figures we can stand behind. These numbers reflect Agent-Engineering teams working against a sensible scope, good product-owner availability and modern stack choices (Swift 6, Jetpack Compose, KMP, CI on GitHub Actions with AI test selection). They are not 2019 numbers, and they are not the inflated estimates some analyst reports publish.

Mobile MVP with AI features, single platform

iOS-only or Android-only. 10–14 weeks; typically 55–90k USD. Covers up to 15 core screens, third-party auth, payments, analytics, Apple-Intelligence or Gemini Nano-based writing/summarisation features, CI/CD and a basic admin web.

iOS plus Android MVP

Both platforms, KMP shared layer. 12–16 weeks; typically 85–140k USD for a CRUD-style product with AI features and analytics. Video, telemedicine and marketplaces with live state are higher and depend on media infrastructure choices; see our mobile cost guide for a scope-by-scope breakdown.

Video, telehealth or live-streaming mobile app

Real-time video calls or streaming on both platforms. 16–22 weeks; typically 120–220k USD depending on WebRTC vs HLS, media server choices and compliance. See our AI video streaming guide and cross-platform video app CTO framework.

Vision Pro native app on top

Add-on only. 6–10 additional weeks; 45–90k USD extra. For most products we do not recommend it — see section 05 above.

A decision framework — pick your mobile stack in five questions

Q1. What is the real-time/graphics intensity of the app? If you are doing live video, camera, AR, games or > 60fps animation, stay native. For forms, dashboards and content apps the cross-platform savings are real and safe.

Q2. Where are your engineers coming from? A strong React/TypeScript team moves fastest in React Native; a Kotlin-first backend team moves fastest in KMP; a design-led team often moves fastest in Flutter. Hiring against a stack your team does not know is the single biggest timeline killer.

Q3. How quickly must you support new OS features? If the answer is “day one” (Apple Intelligence, Live Activities, Dynamic Island, widget deep-links), stay native. Cross-platform wrappers typically arrive 1–3 quarters behind.

Q4. What is your long-horizon maintenance budget? Two codebases mean two engineers, two release cycles and two security reviews forever. A single KMP or Flutter codebase is materially cheaper year three onwards.

Q5. Is your target audience biased toward iOS or Android? For paid subscription consumer apps in North America and the UK, iOS will pay the bills while Android delivers reach. For global, emerging-market or enterprise audiences, Android usually leads installs; see Speakk’s zero-data messaging launch in South Africa for a real-world example where Android-first was the only sensible call.

Five pitfalls we keep seeing in 2024 to 2026 migrations

1. Hard-wiring product features to “the new Siri.” The deeper Apple Intelligence Siri layer was postponed twice; every product that promised it in marketing had to walk the promise back. Treat named vendor features as nice-to-have, not core.

2. Forgetting that Apple Intelligence needs iPhone 15 Pro+ or an M-iPad. Apps that assumed coverage on all installed devices shipped broken fallbacks. Design for a three-tier fallback: Apple Intelligence, your own local model, hosted API.

3. Skipping the Swift 6 concurrency audit. The migrations that went sideways in 2024 were the ones that enabled strict concurrency in CI without a dedicated sprint to fix @Sendable violations. Budget a week per mature module.

4. Treating tablets as “big phones.” Google’s Desktop Windowing and M4 iPad Pro raised the baseline. Apps that did not adapt layouts shipped to productivity buyers who returned them inside the first 30 days.

5. Funding a Vision Pro app out of MVP budget. The unit economics do not support it yet. Build it as a phase-2 experiment funded by a marketing or R&D budget, not the core engineering line.

KPIs — what to measure on a modern mobile app

Quality KPIs. Crash-free users ≥ 99.5% (iOS) and ≥ 99.0% (Android), cold-start P95 < 1.8s on iPhone 13 and Pixel 7, scroll jank < 0.5% frames over 16.7 ms on 60 Hz panels. If your app ships AI features, add token-latency targets (first-token < 600 ms on-device) and inference-error rate < 0.2%.

Business KPIs. Day-30 retention, subscription conversion (free → paid), MAU/DAU, ARPU and average session length. For apps with AI features track AI-feature activation (% of users who touch the feature) and AI-feature retention (did they come back to it in week 2) — novelty AI features without retention are a drag on app size, not a product moat.

Reliability KPIs. API error budget (99.9% backend uptime), push-notification delivery ≥ 97%, crash-triage mean-time-to-detect < 30 min, regression escape rate < 2%. With AI test selection in CI, these are achievable without blowing up the device-farm budget.

When NOT to ship a native mobile app

Not every 2024 trend means “ship an app.” If your user base touches your product a few times a month on a work laptop, if you need no push, camera or background sync, and if App Store discovery is not part of your distribution plan, a modern PWA or responsive web app is the right call — cheaper to build, cheaper to maintain, zero review overhead. The only thing you lose is Apple-Intelligence and Gemini-Nano on-device features, and for many B2B tools that is fine.

A second case: if you are pre-product-market-fit and your assumption set is still moving, shipping a PWA to validate is safer than committing to iOS and Android build-up-front. You can always split into a native app in phase 2.

FAQ

What to read next

Ready to turn 2024’s shifts into your 2026 app?

The honest summary of mobile development in 2024 as a platform for mobile development in 2026: Swift 6 and Jetpack Compose became the default, on-device AI stopped being a demo, Vision Pro did not break out, Apple Intelligence shipped most of what it promised, cross-platform split into three honest choices, and AI finally moved into the dev loop itself. For a 2026 build that means pick native where you need real-time and new-API velocity, pick KMP or Flutter where shape-of-product allows, treat Vision Pro as a bonus, plan a three-tier AI fallback, and pay for the Swift-6 concurrency audit up front.

If you are turning any of that into a real product in the next two quarters, we are happy to pressure-test your plan. Bring a product spec, a rough screen count and your deadline; we will come back with a stack, a team shape and an honest estimate in a 30-minute call.