Mobile app development services that build your app or join your team

Our mobile app development services answer the stack question in writing before any app code, and 80%+ of our engineers are senior or above.

Illustration of the same app open on an iOS phone and an Android phone, with a release checklist beside themIllustration of the same app open on an iOS phone and an Android phone, with a release checklist beside them

SCOPE

What does a mobile app team deliver?

A mobile app team takes an app from the first requirements to release day and keeps it running after that. The work covers discovery, design, native or cross-platform engineering, testing on real devices and support once users arrive. We do it for iOS, Android or both, as a project we deliver or with engineers who join your team.

Mobile work is part of our software development practice, so the backend and APIs your app talks to can come from the same company, as they did for the time-tracking apps on this page. An app is only as quick as the server behind it, and a slow API shows up on the phone as a slow app.

Two services often come before the code. If you are launching a mobile MVP, discovery is where the scope gets cut down to what proves the idea. If the screens aren't designed yet, UI/UX design for mobile products covers user research, user flows, clickable prototypes and the visual UI handed to developers.

Illustration of an app's path from a sketch and a prototype to a build tested on several phonesIllustration of an app's path from a sketch and a prototype to a build tested on several phones

NATIVE OR CROSS-PLATFORM

Native or cross-platform: which fits your app?

Deep device features point to native

If the app depends on Bluetooth devices, background tasks, sensors or a new iOS or Android feature on the day it ships, native code in Swift or Kotlin reaches it directly. Flutter and React Native get there through plugins or native modules, which is more code to write and keep working.

Both stores on day one, or one store first

A launch on both stores on the same day favors one shared codebase. If the first release only has to show that people want the thing, one platform is often enough, and native on that platform is an honest answer. Look at where your users are before you pay to reach both. The second app can come once the first has earned it.

New OS versions and the plugins in between

Much of what a cross-platform app does on the phone goes through third-party plugins. When Apple or Google ships a new iOS or Android version, a plugin can trail behind it, and the app waits for its maintainer or for your team to patch it. Count the plugins your feature list needs before you choose, and check who maintains each one.

Platform conventions or one brand look

Native apps follow each platform's own controls and navigation without extra effort. Flutter draws every pixel itself, so one consistent brand look is easy and platform-specific behavior is extra work. React Native renders the platform's own components from shared code, which keeps more of the native feel.

Who owns the app after launch

Choose a stack the people running the app in two years can own. A team that already writes React will read React Native code on day one. A team with Kotlin engineers may prefer native Android, or Kotlin Multiplatform to share business logic while each platform keeps its own screens. A stack nobody in-house can read ties you to whoever wrote it.

What every later update costs

Two native apps mean each change is written twice, reviewed twice and released twice. Shared code means it is written once, but it is still tested on both platforms. One codebase is not one test pass. Over a few years of updates the difference adds up, so we weigh it in discovery and give you the recommendation in writing, with the reasons behind it.

Illustration of a checklist weighing native apps against one shared cross-platform codebaseIllustration of a checklist weighing native apps against one shared cross-platform codebase

PLATFORMS

Which platforms we build for

Cross-platform means one codebase for both stores, written in Flutter and Dart or in React Native. It fits an app that has to reach iPhone and Android users at the same time, with the same screens on both, and few features that reach deep into the device.

Native means one app per platform, in Swift for iOS and Kotlin for Android, each built with the platform's own tools. It earns its cost when the app lives close to the hardware, or when it has to look and behave exactly like the rest of the phone.

PROOF BY STACK

Ask any vendor what each app was built in

A portfolio says little until you know what each app was built in. Ours covers native Android, native iOS and Flutter.

Arterio: native Android in Kotlin

Arterio is a native Android app for patients with hypertension, written in Kotlin with MVVM, Room and LiveData on Material Design 2.0. It reads electronic blood pressure monitors over Bluetooth, and patients can still type a reading in by hand when they need to. Readings show as graphs and trends, and the measurement history is shared securely with doctors. Arterio's case study records 70% less error in blood pressure logs than paper logs.

Time tracking: Android and iOS around PeopleSoft

We built an Android app in Java and an iOS app in Swift on top of PeopleSoft, for a global managed staffing and services company. Employees log arrival, departure, lunch breaks and daily duties on the phone and send the timesheet to their supervisor. The apps talk to a Java and Spring service we also built, which writes each submitted timesheet into PeopleSoft. Per the time-tracking case study, logging an entry in the apps is 40% faster than through PeopleSoft's native interface.

Social video app: one Flutter codebase, both stores

A client needed its app on iOS and Android, so we built a social video app on one Flutter codebase that serves both platforms, and nobody has to maintain two native apps. Users record and manage video in it, and the app generates a PNG preview of each recording so people can browse by sight. It was released on the App Store and Google Play.

Match video analysis: Swift apps on iPad

For a company in football, we built four Apple apps on one Java and Spring backend. Two of them run on the iPad, both in Swift. Staff tag key moments of a match in one, and coaches go straight to each tagged moment on a timeline in the other. A macOS transmitter and a macOS work station complete the set.

Illustration of a phone app showing a blood pressure trend graph, paired with a Bluetooth blood pressure monitorIllustration of a phone app showing a blood pressure trend graph, paired with a Bluetooth blood pressure monitor

Not sure which stack fits your app?

Tell us what the app must do and who will use it, and we'll say which stack we would pick for it and why.

PROCESS

How a mobile app project runs

Our team works fully remotely, in Agile sprints with bi-weekly demos, Jira for tasks and progress, and Slack for the daily conversation. Discovery comes first, so the stack is settled before anyone writes app code. Step durations are typical ranges, not commitments.

  1. STEP 1

    Discovery phase

    We write the requirements and backlog, design the architecture, recommend native or cross-platform in writing and give you an estimate and plan. A prototype comes in when a flow needs testing.

    2–4 weeks

  2. STEP 2

    Build in sprints

    Engineers show a working build at every bi-weekly demo. AI-written code is reviewed by another AI agent, then by a human engineer, before merge. You make product decisions and accept each milestone.

    MVP: 2–4 months

  3. STEP 3

    Testing on real devices

    Testers check the app by hand on real devices and in BrowserStack, and automation engineers cover iOS and Android journeys with Appium once they settle.

  4. STEP 4

    Release to the App Store and Google Play

    Where release is in our remit, we prepare the store builds and take the app through App Store and Google Play review. Some clients submit it themselves.

  5. STEP 5

    Support and maintenance

    We fix issues, monitor the live app, update it for new iOS and Android versions and add small improvements, in CET/CEST hours or a schedule shifted toward yours. Response times are agreed per client.

WHAT DRIVES COST

What moves the price of a mobile app?

Scope sets the team and the weeks

A mobile app is priced on the engineers it needs and how long they need. Everything else here moves the price by moving one of those two. A bigger scope takes more time, and a launch on both stores at once may take more people.

Platforms and the backend behind the app

One platform or two is the first fork in any estimate. The second fork is the server side. An app that calls an API you already run needs far less than one whose backend, admin tools and notifications are built from scratch.

Features, integrations and design depth

Payments, maps, sign-in and links to your own systems each add work, and so does how far the design goes, from a clean standard interface to custom screens and motion. The range of iOS and Android versions you support decides how much testing every release takes.

Why the number comes after discovery

Before discovery, any estimate is a guess wearing a suit. Discovery writes the requirements, the architecture and the plan, and the estimate is built on them, so you get a figure you can hold a scope to. Until then we can name what moves the price, and discovery turns that into a number.

Illustration of an app feature list next to a delivery plan with milestones for discovery, MVP and releaseIllustration of an app feature list next to a delivery plan with milestones for discovery, MVP and release

HOW WE WORK

Engagement models and terms

Project delivery

We deliver an agreed scope end to end: plan, team, milestones, QA and release. You make the product decisions and accept each milestone.

Fixed price per milestone after discovery, or time and materials against an estimate.

  • Scope changes go through change requests.
  • On fixed-price projects, a warranty period agreed in the contract, usually 30–60 days.

Staff augmentation

Our engineers join your team and work in your process and tools. You manage them; we source, vet and contract them.

Hourly rate per engineer by role and seniority, invoiced monthly.

  • If an engineer isn't the right fit, we replace them within 14 days at no extra cost.
  • Knowledge transfer to the replacement engineer isn't billed.
  • There is no free trial period.
  • 30 days' notice to take an engineer off or end the engagement, with no minimum term beyond it.
  • Out-of-hours on-call only if agreed with you; we set its hours and billing together.
  • After two years, moving an engineer onto your own staff is something we can discuss.

Discovery phase

A short phase before a build: requirements and backlog, architecture, an estimate and a delivery plan.

Fixed price, usually 2–4 weeks.

  • The outputs stay with you whether or not the build continues with us.

Whichever model you choose

  • We reply to an inquiry from the contact form within 24 hours.
  • We sign an NDA before work starts, and IP passes to you on payment.

WHY OCTALANCE

Why this team for your mobile app

Illustration of a mobile team's workspace: a tester checking an app on several phones beside a sprint boardIllustration of a mobile team's workspace: a tester checking an app on several phones beside a sprint board

A stack call not tied to one framework

A vendor that staffs one framework tends to recommend that framework. We staff native iOS, native Android, Flutter and React Native engineers, so the recommendation follows your app.

Manual QA on every published case

Manual QA was part of every project in our case studies. On mobile that means functional, regression and exploratory testing across your users' devices, and a smoke test of each new build.

Research before the first screen

On Arterio, discovery began with cardiologist interviews, four personas and four empathy maps, and design prototypes were approved before development started.

Hours that fit yours

CET/CEST business hours are our default. For a team in another time zone, we choose the location and shift the schedule toward your working day.

Where your code lives

The code usually lives in your repositories. Systems we control are hosted in the EU. Code and data in your own systems stay where you keep them, and we sign a DPA where we handle your data.

TECHNOLOGIES

The mobile stack we work in

Swift

SwiftUI

Kotlin

Jetpack Compose

Kotlin Coroutines and Flow

Hilt

Retrofit

Room

Kotlin Multiplatform

Flutter

Dart

React Native

TypeScript

Appium

BrowserStack

Figma

CASE STUDIES

Mobile apps we built for clients

Three of these four stacks were chosen for what the app had to do. Arterio's client chose native Android first because the app reads Bluetooth blood pressure monitors. The match video system got a separate app for each job, so capture runs on the Mac, where the capture hardware plugs in.

The scale differed as much as the stack. The match video system ran about a year with a team of eight. We delivered the social video MVP in two months, and it did its job. Our client validated the need for the product and moved into its growth phase with an in-house team.

A stack for the team that keeps the app

"The app you launch is the smallest it will ever be. We pick the stack for the team that will still be changing it in two years."

Dzmitry Kuchynski, Chief Operating Officer, Octalance

FAQ

Questions to ask before you pick a mobile app team

Native or cross-platform: which should we pick?

Native, when the app depends on the phone's hardware or has to feel exactly like each platform. Cross-platform, when both stores need the same app at launch and most screens match. When an app needs some of each, Kotlin Multiplatform lets two native apps share their business logic and keep native screens on each side.

How much does a mobile app cost to build?

The scope sets the figure, so it comes after discovery. To scope the discovery phase, send us the platforms, the main features, any integrations, and whether a backend or designs already exist. How a build and the engineers on it are priced is in the Engagement models and terms section on this page.

How long does it take to build a mobile app?

An MVP usually takes 2–4 months, after a discovery phase of 2–4 weeks. Both are typical ranges. A full app's timeline comes out of discovery, once the scope it has to cover is written down.

Who submits the app to the App Store and Google Play?

Whoever the scope names. If release is in our remit, our team prepares the store builds and takes the app through both reviews. If you would rather submit it yourself, we agree that in the scope instead.

Can you take over an app another team built?

Yes. We start with an audit of the code, its dependencies and the deploy and release setup, and you get a written list of findings with what we would fix first. A short handover follows: access, environments, runbooks and a walkthrough from the previous team where one is available. Then the app moves into support and maintenance.

Can your engineers join our team instead of building the app for us?

Yes. Each engineer works full-time for you only, and you interview them before anyone starts.

Is there a React Native app of yours we can look at?

There is no published React Native case yet. What we can show is how our React Native engineers are vetted before they reach your shortlist: a technical skills assessment on React Native at the seniority they claim, a soft-skills evaluation and an analysis of their job history. The real-device testing in our process applies to a React Native app as to any other.