Skip to content

Build

Mobile App Design & Development

iOS and Android apps with the analytics, attribution and lifecycle plumbing that makes app marketing actually work — App Tracking Transparency-aware from launch, server-side event architecture, integrated with the wider marketing stack.

  • ATT-aware attribution from launch, not bolted on later
  • Server-side event architecture that survives platform changes
  • Lifecycle and retention infrastructure built in

App marketing is structurally harder than web marketing. App Tracking Transparency, ATT-driven signal loss, store-platform attribution restrictions and SKAdNetwork constraints all degrade the data marketing teams rely on to optimise. Apps that are built without explicitly accommodating these constraints are usually expensive to market once they ship — the right answer is to design the analytics, attribution and lifecycle infrastructure into the build, not to bolt it on after launch.

What we build

The standard programme covers:

  • iOS native apps (Swift, SwiftUI) where platform-specific UX, performance or capabilities warrant
  • Android native apps (Kotlin, Jetpack Compose) under the same principle
  • React Native cross-platform apps where shared codebase economics outweigh platform-native polish (most consumer-facing apps with broad feature parity)
  • Backend infrastructure: API, authentication, real-time sync, data layer integrated with the wider marketing stack
  • Marketing infrastructure: SKAdNetwork integration, App Store Connect optimisation, deep linking architecture (Branch, Adjust, Singular), attribution APIs
  • Lifecycle infrastructure: push notification engine (OneSignal, Braze, Iterable), in-app messaging, lifecycle stage tracking
  • Analytics: app analytics SDK + server-side event pipeline, integration with the rest of the marketing measurement stack

Why ATT changed everything

Apple's App Tracking Transparency framework, rolled out in iOS 14.5 in 2021, requires apps to ask explicit permission before tracking users across other apps and websites. Opt-in rates settled around 20-30% for most consumer categories. The implication: 70-80% of iOS users became invisible to third-party attribution and most cross-app audience targeting.

The marketing impact was material. Apple's own documentation is the primary source on what ATT does and doesn't allow. Industry response has consolidated around three patterns:

  1. SKAdNetwork integration: Apple's own privacy-preserving attribution API. Required for any app running paid acquisition on iOS. Not optional from a marketing perspective even though it's technically optional from an Apple perspective.
  2. Server-to-server attribution APIs: post-install events sent server-side to ad platforms (Meta CAPI, Google Ads SKAdNetwork integration, TikTok Events API). Recovers some of what ATT removed.
  3. First-party data emphasis: building audiences from in-app behaviour, email signups, account data — durable to ATT changes because it doesn't depend on cross-app tracking.

Apps built BEFORE these patterns were standard usually need significant rebuilding to support them properly. Apps built AFTER them work cleanly with the modern attribution stack.

How a build runs

Discovery to launch

The build process

Typical 16-32 week engagement for a mid-complexity consumer app, depending on platform coverage and feature scope.

  1. Discovery

    Product + technical + marketing scope

    Product definition, user flows, technical architecture, marketing infrastructure scope (attribution, lifecycle, analytics), platform decisions (native vs React Native, iOS-first vs simultaneous launch).

  2. Architect

    App architecture + backend + marketing infrastructure

    Component architecture, state management, navigation, backend API, authentication, attribution SDK selection (Branch / Adjust / Singular / AppsFlyer), lifecycle messaging platform integration.

  3. Build

    Iterative development + testing + integration

    Sprint-based development. Internal testing builds shipped continuously to TestFlight + Firebase App Distribution. Real-device testing throughout. Marketing infrastructure tested end-to-end before launch.

  4. Submit

    App Store + Play Store submission + ASO setup

    App Store Connect listing, screenshots, metadata, App Store Optimisation copy. Apple review process (typically 1-7 days). Google Play submission. Beta cohort distribution before public launch.

  5. Launch

    Phased rollout + monitoring + marketing handover

    Phased Google Play rollout (1% → 10% → 100% over a fortnight). iOS public release. Crash monitoring (Crashlytics / Sentry), performance monitoring, attribution validation. Marketing programme picks up acquisition.

The marketing infrastructure layer

The thing that distinguishes a marketable app from a generic one is the marketing infrastructure built into the architecture. Specifically:

  • Attribution: SKAdNetwork integration on iOS, Google Play Install Referrer on Android, deep linking via Branch/Adjust/Singular/AppsFlyer for cross-platform consistency. The basic question "which marketing channel acquired this user" should have a defensible answer.
  • Event tracking: client-side SDK + server-side pipeline. Events tagged with consistent naming, conversion events flagged for ad-platform integration, all events flow into a central data layer (Segment, Snowflake, BigQuery, mParticle).
  • Push notification engine: OneSignal / Braze / Iterable / native APNs+FCM integration. Lifecycle-aware so messages can be triggered by stage changes, not just broadcast.
  • In-app messaging: contextual prompts at the right moment in the user journey — onboarding, activation milestones, churn-risk intervention.
  • Authentication + identity: durable user identity that links anonymous app behaviour to authenticated user behaviour to CRM record. The infrastructure that makes lifecycle marketing possible.
  • ASO infrastructure: keyword tracking, conversion-rate testing on listing screenshots and metadata, integration with paid app campaigns.

Most agencies that build apps treat these as post-launch upgrades. We treat them as foundational — the architecture cost is similar either way; doing them post-launch typically costs 2-4x more in rework than doing them at build time.

Native vs React Native

Platform decision

When each approach makes sense

Dimension
React Native
Native (Swift / Kotlin)
Codebase
Single codebase for both platforms
Two codebases (iOS + Android)
Cost (initial)
Roughly 1.3-1.5x single-platform native cost
2x single-platform native cost (both built)
Performance
Excellent for most use cases
Best-in-class for performance-critical features
Platform-specific UX
Constrained — looks slightly off-platform
Native feel; matches platform conventions exactly
Hardware integration
Library coverage uneven
Full platform API access
Best for
Most consumer apps with broad feature parity
Performance-sensitive apps, complex platform integration

Default: React Native for most consumer apps. Native when there's a specific reason — gaming, AR, complex media processing, deep platform integration that React Native libraries don't cover well, or brand-experience apps where platform-native feel is critical to perceived quality.

What it costs

App builds are scoped engagements with significant range based on complexity, platform coverage and integration depth. Indicative ranges:

  • Lean React Native MVP (consumer app, 6-10 core screens, basic backend): £80-150k
  • Standard React Native app (consumer or B2B, 15-30 screens, custom backend, marketing infrastructure): £150-400k
  • Native iOS + Android (cross-platform native, complex backend, advanced features): £300-700k+
  • Complex apps with significant proprietary infrastructure (real-time sync, AI features, payments): £500k-£2M+

Ongoing development typically £6,000-£25,000/month per active platform.

Where this service wins

  • Consumer-facing apps where marketing-driven acquisition matters — the marketing infrastructure built into the architecture pays back in lower per-user marketing inefficiency
  • Apps replacing legacy versions built before ATT — usually the rebuild can pay for itself just in attribution recovery
  • B2B mobile apps that need to integrate with the broader marketing and CRM stack — the same architectural principles apply, just with different lifecycle patterns
  • Subscription apps (consumer subscription, fitness, health, productivity) where retention infrastructure is the dominant value-driver

Where it doesn't fit

  • Apps that are essentially mobile-friendly websites — a responsive web app or PWA is usually the right answer at lower cost and faster time-to-market
  • Internal tools that don't need ASO, attribution or marketing infrastructure — generic app development is fine and cheaper
  • Concept-validation MVPs where the question being tested is product-market fit rather than marketing-channel viability — the marketing infrastructure is premature optimisation

Read deeper on this

  • Conversion tracking foundations for AI-led marketing — the cross-platform attribution principles that apply to both web and app.
  • Why your CAC is climbing — and what to do about it — including ATT as a structural force on iOS app CAC.
  • Email & Lifecycle Marketing — the lifecycle work that pairs with mobile push and in-app messaging for retention.

FAQs

Common mobile app build questions

React Native or native — which should we use?

Default React Native for most consumer apps with broad feature parity. Native when there's a specific reason: performance-critical features (games, AR, complex media), deep platform integration React Native libraries don't cover, or brand-experience apps where platform-native feel matters disproportionately to perceived quality.

How long does a build take?

16-24 weeks for a standard consumer React Native app with marketing infrastructure baked in. 24-36 weeks for native iOS + Android. Complex backend or advanced features extend timelines further. Faster timelines usually mean cutting marketing infrastructure (which costs 2-4x more to add post-launch).

How does attribution actually work after ATT?

On iOS: SKAdNetwork as the privacy-preserving baseline (Apple's own attribution API), supplemented by server-to-server attribution APIs (Meta CAPI, TikTok Events API equivalents) and probabilistic modelling for non-opt-in users. On Android: more conventional click and install attribution still works. Cross-platform consistency via Branch / Adjust / Singular / AppsFlyer.

Can you integrate with our existing CRM and marketing stack?

Yes. App identity tied to CRM identity from authentication forward. Events flow into the central data layer (Segment, Snowflake, BigQuery). Lifecycle stage changes trigger across email, SMS, push and in-app messaging from one orchestration layer. The architecture is designed for integration, not isolation.

What about App Store Optimisation (ASO)?

Foundational. Listing copy, keyword research, screenshot conversion testing, App Store Connect tooling integration. Done at build time so the app launches with the foundation in place; ongoing optimisation post-launch is much cheaper than retrofitting.

Do you handle Apple / Google review submissions?

Yes. App Store Connect submission, Apple review process (1-7 day cycle typically), Google Play submission, phased rollout management. We've handled rejections from both platforms — the work involves documenting compliance with the various review guidelines and addressing reviewer feedback.

What about ongoing maintenance after launch?

Native and React Native apps both need ongoing maintenance — OS updates, library updates, security patches, App Store / Play Store policy changes. Typical £6-25k/month for an active app depending on roadmap intensity. Apps without active maintenance accumulate technical debt fast.

How do you handle in-app purchases or subscriptions?

RevenueCat for cross-platform subscription management is our default — handles the App Store / Play Store payment integration, subscription lifecycle events, churn prediction, restoration. Tied into the lifecycle marketing layer so subscription state drives messaging.

Can you migrate an existing app to a new architecture?

Yes — common pattern. Existing app continues running while we build the new version. Phased migration with feature parity validation. User account migration handled to preserve identity. Typical re-build engagements are 60-80% the cost of new builds because product definition is already known.

What about web app or PWA as alternatives?

Often the right answer if the app is essentially a mobile-friendly version of your web product. Faster to build, cheaper to maintain, no app store dependency. We'll tell you that rather than push toward the more expensive option. Native app makes sense when push notifications, deep platform integration, offline behaviour, hardware access or App Store discovery are commercially material.

Sources and further reading

  • Apple — App Tracking Transparency — Apple's developer documentation on the ATT framework.
  • Apple — SKAdNetwork — Apple's documentation on the privacy-preserving attribution API.
  • Google — Play Install Referrer — Google's documentation on Android install attribution.

Next step

Put an AI-powered agency behind your marketing.

Run the Growth Planner for a tailored plan, or scope an end-to-end engagement with our team.