Mobile App Development: When a Prototype Stops Scaling
A client shows up with a working prototype on React Native that starts falling apart at 10,000 DAU: lists lag, push notifications arrive inconsistently, and the release build on Android 14 crashes with IllegalStateException when trying to open the camera. There’s a product, but under load it breaks down. This is a typical entry point—not "we want an app from scratch," but "we have something that’s no longer handling the load." Reach out for a free technical audit of your existing codebase before you invest in a rewrite.
Mobile development today is not about choosing between iOS and Android. It’s about architectural decisions made at the start that you live with for years.
When Does Native Development Make Sense?
iOS apps with Swift and SwiftUI provide direct access to HealthKit, ARKit, CoreML, StoreKit 2. Android in Kotlin with Jetpack Compose gives access to CameraX, WorkManager, ML Kit. The native stack is justified when the app relies heavily on platform APIs, requires maximum performance, or works with biometrics and the Secure Enclave.
In practice, native development is chosen for:
- Fintech apps with biometric authentication and NFC (Apple Pay, Google Pay)
- Medical solutions integrating HealthKit / Google Fit
- AR apps using ARKit / ARCore
- Games and interactive 3D on Metal / Vulkan
- Apps where 120 fps animation is critical (ProMotion on iPhone 13 Pro+)
SwiftUI covers 80% of UI tasks faster than UIKit, but UIKit hasn’t disappeared—complex custom cells, custom transitions, low-level UIScrollView work. Real projects use both frameworks in the same app via UIHostingController and UIViewRepresentable.
On Android, Jetpack Compose has become production-ready in recent years. LazyColumn with remember and derivedStateOf only recomposes where needed—a fundamentally different model from XML + RecyclerView with DiffUtil. But Compose requires understanding: improperly used State inside LazyListScope guarantees unnecessary recompositions and FPS drops.
Which Cross-Platform Framework Fits Your Project?
Flutter renders UI through its own Skia/Impeller engine—the platform doesn’t participate in rendering. This means pixel-perfect consistency across all devices and no "platform" artifacts. Platform components (Maps, Camera, WebView) are connected via platform channels, adding complexity but not blocking.
React Native uses native components through JSI (JavaScript Interface). With the New Architecture (Fabric + TurboModules), synchronous calls from JS to native code now work without serialization through a JSON bridge. This is important for animations and gestures—react-native-reanimated 3 now executes worklets directly on the UI thread.
Comparison by key parameters:
| Criterion | Flutter | React Native | Native (iOS/Android) |
|---|---|---|---|
| Unified UI | Yes (Skia/Impeller) | No (native widgets) | No |
| Performance | Near-native | Depends on JS thread | Maximum |
| Time to market | Faster than native | Faster than native | Slower |
| Platform APIs | Via channels | Via modules/JSI | Direct access |
| Team size | 1 team | 1 team | 2 teams |
| Ecosystem | pub.dev (Dart) | npm (JS/TS) | Swift Package Manager / Maven |
KMM (Kotlin Multiplatform Mobile) solves a different problem—not UI, but business logic. A shared Kotlin module compiles into a .framework for iOS and an Android library. UI remains native on each platform. This is a working solution for teams that already have iOS and Android developers and want to eliminate duplication of logic (parsing, caching, validation).
UX/UI for Mobile: More Than Just Figma
Mobile app design isn’t about transferring a web mockup to a small screen. iOS Human Interface Guidelines and Material Design 3 shape user expectations for gestures, animation timing, and information density. Deviating from these norms isn’t "unique style"—it’s cognitive load.
Prototyping in Figma with Auto Layout and Component Properties allows building a realistic interactive prototype before writing a line of code. Developers receive design tokens—colors, typography, spacing—and import them directly via Figma Variables API. This reduces iteration during the implementation phase.
To validate UX hypotheses before development, use Maze or UserTesting—test specific scenarios on the prototype, not on the built app.
Backend for Mobile App: REST, GraphQL, or Real-Time
The mobile client consumes APIs—REST or GraphQL. The choice isn’t religious: GraphQL is justified for complex nested data structures and when different screens require different field sets of the same entity. REST with JSON:API or OpenAPI is simpler for caching (HTTP cache headers) and monitoring.
For real-time—WebSocket (Socket.IO, native WS) or Server-Sent Events for unidirectional streams. gRPC with protobuf for high-throughput scenarios and internal microservices.
Push notifications via FCM (Firebase Cloud Messaging) and APNs (Apple Push Notification service). Direct integration or through OneSignal/Braze—depends on audience segmentation and A/B testing requirements for notifications.
Analytics and Monitoring: What Happens After Publication
Firebase Crashlytics shows crash-free rate—99.5%+ is considered normal. Below 99% is critical. Crashlytics groups similar crashes by stack trace and shows which devices and OS versions they concentrate on. That’s the first thing we set up before release.
Product analytics—Firebase Analytics, Amplitude, or Mixpanel. Funnels, retention, session duration. It’s not the number of events that matters, but proper taxonomy: user_id, session_id, app_version, platform. Without this, data can’t be segmented.
Performance monitoring—Xcode Instruments (Time Profiler, Allocations, Leaks) for iOS, Android Profiler (CPU, Memory, Network, Energy) for Android. For Flutter—DevTools with Timeline and Memory views.
AI in Mobile App: On-Device or in the Cloud
CoreML on iOS allows running .mlmodel directly on the device. YOLOv8, MobileNetV3, custom classification models—no network, no latency, no data sent to the server. Convert2CoreML or coremltools convert models from PyTorch/TensorFlow.
On Android—TensorFlow Lite with acceleration via NNAPI (Neural Networks API) or ML Kit for ready-made tasks: text recognition, face detection, barcode scanning, translation.
LLM integration—via API (OpenAI, Anthropic, Gemini) with streaming response via SSE. On-device, only small models are currently feasible (Phi-3-mini, Gemma 2B)—via llama.cpp with Metal/Vulkan backend.
Publishing in App Store and Google Play
App Store Review Guidelines—a document you should read before starting development, not before submitting for review. Rejections under 4.3 (Spam—app too similar to others), 2.1 (App Completeness—crashable demo), 3.1.1 (In-App Purchase not implemented where required) mean weeks of lost time.
Google Play is less strict, but Play Integrity API has become mandatory recently for apps handling payment data. MEETS_STRONG_INTEGRITY is a requirement for fintech.
Fastlane automates building, signing, and publishing. match manages certificates via a git repository. CI/CD—GitHub Actions or Bitrise. Every merge to main triggers an automatic build and upload to TestFlight / Firebase App Distribution for testing.
Mobile App Architecture: Decisions That Are Hard to Undo
MVVM—the basic pattern for both iOS (Combine + @Published) and Android (ViewModel + StateFlow). BLoC in Flutter gives a predictable event flow: Event → BLoC → State. Clean Architecture adds layers (Data, Domain, Presentation) and makes business logic independent of the UI framework.
VIPER on iOS and TCA (The Composable Architecture)—for large apps with big teams, where feature isolation and testability of each component are important.
The choice of architecture at the outset determines how easy it is to add a feature a year later and how difficult it will be to test logic separately from UI.
Proper architecture can cut development cost for the second iteration by up to 40% — we’ve seen this firsthand across 60+ delivered projects.
Timeline Benchmarks
Development timelines depend on complexity, availability of ready design and backend:
| Project Type | Estimated Timeline |
|---|---|
| MVP (1 platform, basic features) | 6–10 weeks |
| Full-featured app (2 platforms) | 3–6 months |
| Complex product with AI/AR/fintech | 6–12 months |
| Redesign and refactoring of existing | 4–8 weeks |
Cost is calculated individually after requirement analysis—specifications, design mockups, integration descriptions. Get your project estimated — we’ll prepare a detailed proposal within 2 business days.
What's Included in the Service
Every mobile development engagement delivers:
- Code documentation — architecture decision records, API contracts, build instructions
- CI/CD pipeline — automated builds, code signing, TestFlight / Firebase Distribution
- Store submission — App Store Connect and Google Play Console setup, compliance checks
- 1 month of post‑launch support — crash monitoring, hotfixes, performance tuning
- Design handoff — Figma tokens export, component library, accessibility annotations
Why Partner with Us
With 10+ years in mobile development, we’ve shipped over 60 apps across native (Swift, Kotlin) and cross‑platform (Flutter, React Native) stacks. Our average crash‑free rate across all projects is 99.6%. We know exactly where the hidden pitfalls lie — from provisioning profile rot to ProGuard shrinking that breaks reflection‑based libraries.
Get in touch to discuss your project — we'll help you choose the right stack and estimate the timeline without upselling what you don’t need.