Skip to content
Back to all services

Native & Cross-Platform Mobile

Make the small screen work harder. Use React Native for shared application code or Swift for direct access to platform capabilities, with clear tradeoffs from the start.

Discuss a project
  1. INTERFACE
  2. DEVICE
  3. SYNC
BUILT AROUND THE DEVICE
ARCHITECTURE / IMPLEMENTATION / HANDOVERSCROLL TO EXPLORE ↓
CONTENTSOn this page

Where this fits

For work people need to do regularly on a phone: customers following a service, field teams recording activity, or colleagues reviewing and approving records. We map the real device experience before choosing shared code or platform-specific development.

Example project types

  • Customer apps for membership, bookings, and service tracking
  • Field apps for records, photographs, and job status
  • Internal apps for review, approvals, and notifications
  • Applications using the camera, location, or other device capabilities

Scope of work

  1. Design for small-screen tasks

    Prioritise information and reduce repeated entry. Design navigation, touch targets, and useful system feedback. Cover first use, empty states, denied device permissions, and returning to the app after it has been in the background.

  2. React Native for iOS and Android

    Share code where it makes sense while adapting behavior to each platform. Assess native modules and the target device set before committing, so shared implementation does not become a constraint on the product’s essential tasks.

  3. Swift for iOS-specific work

    Use Swift when direct platform capabilities or a particular iOS interface requirement justify native development. Compare implementation, testing, and maintenance effort with a shared-code approach before selecting the architecture.

  4. Accounts, APIs, and notifications

    Connect membership, sign-in, and business data. Define appropriate session storage and renewal, and plan event-based notifications around user permissions. Any new backend is scoped explicitly rather than assumed to be part of the mobile interface.

  5. Unreliable networks and device access

    Identify which functions can read or save offline, how queued records are sent, and how conflicts are handled when the device reconnects. Assess camera, location, file, or scanning requirements and request only permissions needed for the agreed functions.

  6. Device testing and release preparation

    Agree supported operating-system versions and representative devices. Check startup, memory use, slow networks, and upgrades from earlier releases. Prepare signed builds, version information, and store-submission materials within the agreed scope.

From scope to handover

How the work moves

ScopeBuild / verifyHandover
  1. Understand the working environment

    Identify mobile tasks, network conditions, devices, required platform capabilities, and the backend systems already available.

  2. Prototype and select the platform

    Review important journeys and test risky elements such as native modules or offline synchronization before choosing the implementation approach.

  3. Build and connect the systems

    Provide test builds in stages. Review APIs, authentication, and data-state handling together with the backend team.

  4. Verify on the agreed devices

    Check key tasks, permissions, network conditions, and upgrades. Let a pilot group validate the app against their actual work.

  5. Prepare release and handover

    Package builds, document the build process, and prepare publication through client-owned accounts. Hand over versioning and troubleshooting procedures.

What you receive

  • Source code and platform build instructions
  • Tests on the agreed device matrix
  • Release packages and store submission preparation
  • Release management and update documentation

Acceptance checks

  • Core journeys pass on the agreed devices and operating-system versions
  • Slow networks, disconnected states, and denied permissions have understandable behavior
  • Sign-in, sign-out, and information access match user roles
  • Installation, updates, and API connections are checked against the specified environments
  • Builds, code, documentation, and agreed publication materials are ready for handover

Before we start

Useful information for scoping

  • User groups, core tasks, and examples of the intended workflow
  • Target platforms, devices, and offline requirements
  • API documentation, account systems, and the backend contact
  • Developer-account ownership, content, policies, and required publication information

Scope boundaries and costs

New backend work, specialist device integration, migration, and reporting need explicit scope where required. Developer-account and third-party charges follow the agreement. Store approval and review timing are controlled by the stores; an external approval date is not guaranteed.

After handover

Handover covers agreed build, signing, and version-management procedures. Post-release monitoring, updates for new operating systems, and additional device support belong in a defined maintenance plan, with clear account ownership and access responsibilities.

Common questions

Should we choose React Native or Swift?

Consider target platforms, device capabilities, and the receiving team. React Native supports shared iOS and Android code; Swift is used for direct iOS development. We assess the risky requirements before choosing, rather than deciding from platform count alone.

Can the entire app work without an internet connection?

This must be decided function by function. Reading saved information or queuing records may work offline, while transactions requiring current server data or confirmation may need a connection. Storage limits and conflict resolution need explicit design.

What if we do not have an API or administration system?

Backend development can be a separate part of the project. We distinguish the mobile app, APIs, database, and administrator interface so each can be estimated, tested, and handed over clearly.

Do you help submit the app to the stores?

Build preparation and submission can be included using client-owned accounts. The account holder supplies and approves the necessary information. Requests for changes from a store are assessed against their cause and the project agreement.

What needs maintenance after publication?

Error monitoring, OS and device compatibility, API changes, and external services all need attention. A maintenance agreement specifies support periods, response windows, and which updates are covered.

Start with the work the system needs to do.

Share your goals, current systems, and known constraints. If the documentation is not ready, a description of the task and an example workflow are enough to begin the conversation.

Discuss a project