Native iOS: Swift, SwiftUI
For iPhone and iPad apps. We have shipped Swift in the time-tracking iOS app and the iPad apps for match video analysis.
Our iOS engineers work in Swift and SwiftUI, and join your team or build the app with us.
Our mobile app development services answer the stack question in writing before any app code, and 80%+ of our engineers are senior or above.


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


NATIVE OR CROSS-PLATFORM
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.
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.
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.
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.
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.
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.


PLATFORMS
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.
For iPhone and iPad apps. We have shipped Swift in the time-tracking iOS app and the iPad apps for match video analysis.
Our iOS engineers work in Swift and SwiftUI, and join your team or build the app with us.
Our Android engineers work with Jetpack Compose, Coroutines and Flow, Hilt and Retrofit. Arterio, our shipped Android case, runs on Kotlin with MVVM, Room and LiveData.
We also maintain older Java Android apps and migrate them.
One Dart codebase for iOS and Android. The social video app on this page is our Flutter build, released on both stores.
TypeScript or JavaScript shared across iOS and Android, from engineers who can join your team. A natural pick when your web team already writes React.
PROOF BY STACK
A portfolio says little until you know what each app was built in. Ours covers native Android, native iOS and Flutter.
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.
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.
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.
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.


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
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.
STEP 1
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
STEP 2
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
STEP 3
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.
STEP 4
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.
STEP 5
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
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.
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.
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.
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.


HOW WE WORK
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.
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.
A short phase before a build: requirements and backlog, architecture, an estimate and a delivery plan.
Fixed price, usually 2–4 weeks.
WHY OCTALANCE


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 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.
On Arterio, discovery began with cardiologist interviews, four personas and four empathy maps, and design prototypes were approved before development started.
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.
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
Swift
SwiftUI
Kotlin
Jetpack Compose
Kotlin Coroutines and Flow
Hilt
Retrofit
Room
Kotlin Multiplatform
Flutter
Dart
React Native
TypeScript
Appium
BrowserStack
Figma
"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
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.
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.
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.
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.
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.
Yes. Each engineer works full-time for you only, and you interview them before anyone starts.
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.