Swift & React Native App Development
A mobile app is less about drawing screens than keeping field data intact. We validate device performance and native integration first, then define the boundary between Swift and React Native from the results.

Design scenario: field inspection records app
240 technicians carry out 1,800 equipment inspections a day across 36 sites. Each job contains 12 checklist entries, eight photos averaging 1.5MB each, and roughly 12MB of attachments, with up to eight hours offline. The scale and timings are design inputs and verification targets.
- People and sites
- 240 people, 36 sites, 1,800 inspections per day
- Record size
- 12 checklist entries and eight photos averaging 1.5MB, roughly 12MB per job
- Offline allowance
- Up to 8 hours; a local queue of 100 jobs and roughly 1.2GB of photos
- Device sample
- Release builds on iPhone SE (3rd generation), iPhone 15, Galaxy A54, and Galaxy S24
- Synchronization
- Clean up local attachments only after durable server acknowledgement
Put acceptance criteria at the end of a record, not the first screen
An inspection app succeeds not when its login screen appears, but when a technician’s photos and results reach the right organization without duplication and a reviewer can inspect their history. Input must remain intact when the network disappears. The next action must also be clear when camera permission is denied, storage is low, or the app is pushed into the background.
| Flow | Acceptance criterion | Verification target |
|---|---|---|
| Start an inspection | Open work only after checking organization, site, and equipment permissions | Work in another organization cannot be viewed or edited |
| Local save | Store 12 checklist entries and 8 photos at roughly 12MB per job | Local save p95 at or below 100ms; queued state survives app termination |
| Capture a photo | Temporarily store photos, notes, and measurements with the same inspection item | Camera entry p95 at or below 800ms; explain permission and storage failures |
| Submit offline | Preserve up to 8 hours and a queue of 100 jobs / roughly 1.2GB | When free storage is insufficient, guide the user to clean up or transmit before a new capture |
| Synchronize | Apply the same record only once even if it is sent repeatedly | No duplicate photos or inspections after retries |
These criteria come before choosing Swift or React Native. The framework must reliably carry this flow through on the devices that matter.
Design offline synchronization as a state machine with server rules
“Upload when connected” is not enough to explain duplicates and conflicts. Give each inspection record a stable client-generated identifier and change order. Treat photo files as separate upload jobs, and let the server’s inspection record expose the attachment state before a photo arrives. Background transfer depends on the operating system’s timing, network, and power policies, so the app does not promise background completion. When reopened, it checks the remaining queue and resumes.
| State | Transition condition | What the user sees |
|---|---|---|
draft | Input has begun but has not been submitted | Saved locally |
queued | Submitted or autosaved and awaiting transmission | Waiting to upload |
uploading | Network and authentication are valid | Uploading photos |
synced | The server has verified the idempotency key, file integrity, and authorization | Synchronization complete |
attention | Authorization, validation, conflict, file, or storage-space error | Needs attention |
Offline “submit” means queued for transmission; it is not the server’s final approval. The server owns organization boundaries and the final authorization decision. It does not trust an organization ID sent by the app, and checks that the access token’s user, organization, and role match the request target on every request. Update requests include an idempotency-key and record version so network retries cannot apply the same change again. Local photos are cleaned up only after a response confirms the server has durably received and finalized them.
When two devices edit the same record, do not overwrite with the last save. If the base version differs from the server, return 409 with the current version and changed fields, then move the app to attention. The user compares the local change with the server version and submits again; automatic retries with a new version are prohibited. Edits to an already approved record are handled as a separate change request that retains the approved version.
Each photo has an attachment_id fixed at capture time and a content hash, and uses the same identifiers when upload begins, retries, and completion is confirmed. The server prevents duplicates for the organization / record / attachment_id combination and returns the existing upload or attachment result for a repeat request with the same hash. A different file with the same ID is rejected as a conflict. It confirms object size and hash and finalizes the attachment reference before responding complete; unfinished temporary objects are cleaned up under an expiry policy.
- Local record
On input, store the record ID, state, and attachment references in an encryptable local store
- Schedule transmission
Run retryable work when the OS permits network, power, and signed-in conditions; check unrun work again when the app resumes
- Server validation
Check tenant permissions, idempotency key, and version, then issue attachment upload authorization
- Finalize
Clean up local attachments and move to complete only after durable server receipt and approval
Validate camera, push, and deep links at the product boundary
The risky parts of a field app are usually platform features, not a list UI. Camera testing must cover capture quality, EXIF handling, large files, and background transitions together. Push is not merely receiving a notification: a notification chosen on the lock screen must lead safely to the correct organization, inspection, and authorization state.
| Feature | App responsibility | Server responsibility |
|---|---|---|
| Camera and photos | Permission, capture, compression policy, local references, failure presentation | Upload sessions, file validation, retention policy |
| Push | Permission request, token registration, tap handling, deep-link routing | Calculate recipients by organization and role; process expiry and revocation |
| Deep links | Hold routes before and after sign-in, transition screens, manage accessibility focus | Make the final check that the target exists and is authorized |
| Authentication | Secure token storage, expiry guidance, sign-in-again flow | Issue and revoke sessions, enforce tenant boundaries, retain audit records |
A deep link does not carry authorization. The app interprets only the destination, while the server decides whether the current session may access it. If a token has expired, it retries the original destination after sign-in; work that has been cancelled or whose permission has been removed returns to the list instead.
Separate shared code from device-specific code first
Even with React Native, modules such as camera, push, secure storage, and file transfer can retain native boundaries. Swift is an open-source language that can be used outside Apple platforms, but here it means building an iOS app with Swift and Apple’s native UI and SDKs. That route handles iOS integration directly; if Android is needed, it owns a separate product surface and delivery path. Do not reduce this distinction to a single “code reuse rate.”
| Area | Swift-based iOS app | React Native | Decision criterion |
|---|---|---|---|
| Inspection flow and validation rules | Implemented inside the iOS app | Candidate for shared domain and screen logic | Simultaneous Android launch and rate of change |
| Capture and file transfer | Direct control through Apple frameworks | Native-module or verified-library boundary | Large-file, background, and recovery requirements |
| Push and deep links | Implemented with the platform lifecycle | Combination of shared routing and platform initialization | Sign-in transitions and security policy |
| Performance diagnosis | Device tools and Apple profiling path | Release builds; observe native and JS boundaries together | Where the slow path actually occurs |
React Native’s New Architecture is a foundation for improving interaction with native code and concurrent rendering. It does not by itself complete validation of file upload, permissions, animation, or SDK compatibility. Check the official New Architecture guide alongside the support boundaries of the SDKs you will actually use.
Measure on the same devices, with the same data, in release builds
An emulator or debug build on a development computer does not stand in for the responsiveness of a shipped app. Use release builds on iPhone SE (3rd generation), iPhone 15, Galaxy A54, and Galaxy S24 as test samples, recording the OS version, app build number, and server version on every run. Separate cold starts from starts after recent use, and repeat with the same photo count, file sizes, and network profile.
| Measurement | Condition | Acceptance target |
|---|---|---|
| App start and open work | 50 cold starts on iPhone SE (3rd generation) and iPhone 15 | p95 time to first interaction at or below 2 seconds |
| Local save | Record 12 checklist entries and photo references | Save completion p95 at or below 100ms |
| Enter camera | Open the capture screen from an inspection item after permission is granted | Preview visible p95 at or below 800ms |
| Offline retry | Up to 8 hours disconnected; queue of 100 jobs / roughly 1.2GB; app exit and token expiry | Restore transmission-pending state with no omissions or duplicates after resuming |
| Thermals and battery | Repeat capture, compression, upload, and return to list for 30 minutes | Continue to meet acceptance criteria without thermal warning or forced termination |
| Accessibility | Large text, VoiceOver/TalkBack, reduced motion | Verify reachability of core actions and communication of state |
On iOS, compare the Swift candidate and React Native candidate on the same iPhone SE (3rd generation) and iPhone 15, with the same OS, photo data, and release builds. On Android, validate the React Native candidate separately against Android acceptance criteria on Galaxy A54 and Galaxy S24. Do not rank iOS and Android measurements directly. Apple provides Instruments and XCTest measurement tools, and React Native also advises checking performance in release builds.
Design the delivery path alongside the feature list
Mobile delivery is not a procedure to add in the final week. Separate app identifiers, signing, environment-specific APIs, push certificates, privacy disclosures, crash collection, and beta groups early. Define what an older app receives and displays when the production API contract changes.
| Area | Decision required | Owner to confirm |
|---|---|---|
| Environments | Separate development, verification, and production APIs and secrets | App and server owners |
| Observability | Identify sync failures, authentication errors, crashes, and upload delays | Operations owner |
| Data | Photo retention period, deletion requests, audit history | Product and security owners |
| Updates | Forced-update conditions and backward-compatibility range | Product owner |
This structure matters more as the product grows. The server must remain the source of truth for data and permissions, the app must retry safely under network conditions, and operators must be able to see where a failure occurred.
Build two implementation candidates quickly with AI, then choose on real devices
AI can accelerate screens and API connections, test drafts, and repetitive state handling. It does not automatically make camera permissions, offline recovery, platform lifecycles, or store signing correct. Generated code still needs human review for security, error handling, accessibility, and operating conditions.
When the technology choice is uncertain, implement the same inspection flow in a Swift-based iOS candidate and a React Native iOS candidate. Use the same API contract; the same data of 12 checklist entries and eight photos averaging 1.5MB; the same iPhone SE (3rd generation), iPhone 15, OS, and release-build settings. On Android, check React Native’s Android acceptance criteria separately on Galaxy A54 and Galaxy S24. The test is not “did development finish quickly?” but whether record preservation, duplicate prevention, device responsiveness, and native integration pass.
Once both iOS candidates meet the criteria, compare shared scope, delivery operations, and maintenance cost. If one fails on the critical path, strengthen the native module or choose platform-specific implementation. As AI lowers the cost of comparison, measured experience quality on real devices can take priority over team familiarity.