Services

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.

An aircraft study rendered in paper, metal, and graphite

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.

Core acceptance criteria
FlowAcceptance criterionVerification target
Start an inspectionOpen work only after checking organization, site, and equipment permissionsWork in another organization cannot be viewed or edited
Local saveStore 12 checklist entries and 8 photos at roughly 12MB per jobLocal save p95 at or below 100ms; queued state survives app termination
Capture a photoTemporarily store photos, notes, and measurements with the same inspection itemCamera entry p95 at or below 800ms; explain permission and storage failures
Submit offlinePreserve up to 8 hours and a queue of 100 jobs / roughly 1.2GBWhen free storage is insufficient, guide the user to clean up or transmit before a new capture
SynchronizeApply the same record only once even if it is sent repeatedlyNo 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.

Client record states
StateTransition conditionWhat the user sees
draftInput has begun but has not been submittedSaved locally
queuedSubmitted or autosaved and awaiting transmissionWaiting to upload
uploadingNetwork and authentication are validUploading photos
syncedThe server has verified the idempotency key, file integrity, and authorizationSynchronization complete
attentionAuthorization, validation, conflict, file, or storage-space errorNeeds 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.

Separate synchronization paths for records and photo uploads
  1. Local record

    On input, store the record ID, state, and attachment references in an encryptable local store

  2. Schedule transmission

    Run retryable work when the OS permits network, power, and signed-in conditions; check unrun work again when the app resumes

  3. Server validation

    Check tenant permissions, idempotency key, and version, then issue attachment upload authorization

  4. 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.

Platform-integration responsibilities
FeatureApp responsibilityServer responsibility
Camera and photosPermission, capture, compression policy, local references, failure presentationUpload sessions, file validation, retention policy
PushPermission request, token registration, tap handling, deep-link routingCalculate recipients by organization and role; process expiry and revocation
Deep linksHold routes before and after sign-in, transition screens, manage accessibility focusMake the final check that the target exists and is authorized
AuthenticationSecure token storage, expiry guidance, sign-in-again flowIssue 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.”

Implementation-boundary comparison
AreaSwift-based iOS appReact NativeDecision criterion
Inspection flow and validation rulesImplemented inside the iOS appCandidate for shared domain and screen logicSimultaneous Android launch and rate of change
Capture and file transferDirect control through Apple frameworksNative-module or verified-library boundaryLarge-file, background, and recovery requirements
Push and deep linksImplemented with the platform lifecycleCombination of shared routing and platform initializationSign-in transitions and security policy
Performance diagnosisDevice tools and Apple profiling pathRelease builds; observe native and JS boundaries togetherWhere 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.

Release-candidate verification
MeasurementConditionAcceptance target
App start and open work50 cold starts on iPhone SE (3rd generation) and iPhone 15p95 time to first interaction at or below 2 seconds
Local saveRecord 12 checklist entries and photo referencesSave completion p95 at or below 100ms
Enter cameraOpen the capture screen from an inspection item after permission is grantedPreview visible p95 at or below 800ms
Offline retryUp to 8 hours disconnected; queue of 100 jobs / roughly 1.2GB; app exit and token expiryRestore transmission-pending state with no omissions or duplicates after resuming
Thermals and batteryRepeat capture, compression, upload, and return to list for 30 minutesContinue to meet acceptance criteria without thermal warning or forced termination
AccessibilityLarge text, VoiceOver/TalkBack, reduced motionVerify 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.

Operational checks before release
AreaDecision requiredOwner to confirm
EnvironmentsSeparate development, verification, and production APIs and secretsApp and server owners
ObservabilityIdentify sync failures, authentication errors, crashes, and upload delaysOperations owner
DataPhoto retention period, deletion requests, audit historyProduct and security owners
UpdatesForced-update conditions and backward-compatibility rangeProduct 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.

References