// service · native mobile
Native iOS and Android.
Built by people who've shipped them at scale.
Real Swift. Real Kotlin. The kind of mobile build that gets featured, not the kind that gets one-starred for a 4-second cold start.
rot8 native mobile development ships iOS and Android apps in Swift and Kotlin — not React Native, not a web wrapper. Senior mobile engineers who've shipped apps for fintech, marketplace, health, and consumer at scale. We pick native when scale, performance, hardware access, or App Store positioning demand it — and we'll tell you when it doesn't.
- From €60k single-platform
- From €110k dual-platform
- Swift · Kotlin
// when native, when not
The honest scoping conversation.
Native is the right call when one or more of these is true: your product needs iOS-grade gestural fluency, sub-100ms haptic-grade interactions, deep hardware access (camera ML, Bluetooth, NFC, ARKit), background processing the OS only grants to native processes, or App Store-feature-grade polish.
It's the wrong call when your product is a content-driven CRUD app, you're testing market fit, you have a single small team, or your roadmap will only ever ship to one platform. In those cases we'll point you at responsive web or a React Native engagement (which we sub-contract; we don't pretend to be specialists in cross-platform).
We turn down native engagements where the value is web-replaceable. Honest scoping is part of the engagement.
// what we ship
The deliverables list.
- Native iOS — Swift / SwiftUI / UIKit interop where needed; Combine + Swift Concurrency; CoreData / SwiftData / Realm depending on data shape; deep linking, push, App Clip when scope warrants.
- Native Android — Kotlin / Jetpack Compose; Coroutines + Flow; Room / SQLDelight; deep linking, push, Wear OS integration when scope warrants.
- Shared back-end + API design — REST or GraphQL for the mobile clients; we own the API contract end-to-end.
- Offline-first where applicable. The hardest part of mobile is the network. We design for plane mode by default.
- Release pipelines — Fastlane on iOS, Gradle on Android, TestFlight + Play Console internal tracks set up on day one.
- Crash + observability — Sentry, Bugsnag, or your tool. Crash-free rate above 99.5% is the floor we target.
- App Store + Play Store submission — we handle review, including the submission iterations that always happen.
// at scale
What “shipped at scale” actually means.
The team has shipped:
- Consumer apps with 1M+ MAU.
- Fintech apps with PCI / PSD2 compliance and bank-grade security review.
- Marketplaces with real-time bidding flows and sub-200ms latency budgets.
- Health apps under HIPAA + GDPR overlapping.
- Apps that have been featured by Apple in their respective categories.
We don't list which ones publicly because most clients prefer it that way. We'll show specific case studies under NDA in the assessment call.
// shapes
Engagement shapes.
| Shape | Duration | Scope |
|---|---|---|
| Single-platform MVP | 10–14 weeks | One platform (iOS or Android), scoped MVP, App Store live |
| Dual-platform launch | 16–24 weeks | iOS + Android in parallel, shared API, both stores live |
| Mobile addition to existing product | 8–16 weeks | You have web; we add the native layer with the API work as part of scope |
Pricing follows Ship and scales with platform count. Single-platform from €60k; dual from €110k.
// what we don’t do
Cross-platform, hybrids, one-off submissions.
- React Native, Flutter, or any cross-platform framework. We have opinions; if cross-platform is right for you, we’ll refer you out.
- Hybrid wrappers (Capacitor, Cordova). If your product needs a real app, build one.
- “Mobile-only” engagements where the API is someone else’s problem. The boundary between API and client decides whether the app feels good. We own both.
- One-off App Store submissions for an app we didn’t build. Submission is bundled with builds, not sold standalone.
// quick answers
Native mobile, common questions.
Why does rot8 build native instead of React Native?
Because at the scale our clients ship to, the tradeoffs of a cross-platform framework — bridge cost, gesture fidelity, OS-version drift, hiring depth — outweigh the dual-build cost. For most consumer or fintech apps, native is faster to ship well, even if it’s slower to ship a barely-working version. We’ll recommend cross-platform when it actually fits.How long does it take to build a native iOS or Android app?
A focused single-platform MVP takes 10–14 weeks from kickoff. Dual-platform iOS + Android in parallel takes 16–24 weeks. Adding a native layer on top of an existing web product, where the API needs partial rework, lands at 8–16 weeks. We commit to the timeline at discovery and protect it with bi-weekly demos and TestFlight builds from week three.How much does native mobile development cost?
Single-platform engagements start at €60,000 and scale with feature count and platform-specific complexity. Dual-platform iOS + Android in parallel starts at €110,000. Final pricing depends on backend work, hardware integrations (camera ML, BLE, NFC), compliance overlay (HIPAA, PCI, GDPR), and any third-party SDK depth. Discovery sprint is €8,000 and credits toward the build.Can rot8 take over an existing native codebase?
Yes, if the codebase is recoverable. We do takeovers when the prior team is fully gone and the architecture isn’t actively on fire. If it’s mid-fire, Technical rescue is the right shape. If the codebase is unrecoverable, we’ll say that on day one rather than charging you to discover it in month three.
// next step
Three projects this quarter. Two remain.
Apply with the four-step form. We respond inside 48 hours, every time, with a real reply from a named founder.