iOS and Android mobile app development

For companies and startups with an app idea, we design and build mobile apps for iOS and Android and release them on the App Store and Google Play. Depending on the project we use Kotlin Multiplatform or React Native, and where the app needs one, we also build the backend and admin panel behind it.

Platform

Kotlin Multiplatform · React Native · iOS · Android

01Who it is for

When commissioning a mobile app makes sense, and when it does not

A good fit

  • Testing an idea with a first version (MVP)

    We build not every feature, but the smallest version that shows whether the idea works. Which features make the first release and which wait is written down with you in the scope document; the ones that wait move to the list for the next release.

  • Businesses that want an app for their customers

    Moving something your customers already do by phone or on your website into an app: booking, ordering, loyalty points or account tracking. An app like this usually connects to a system you already run, and we map that connection at the start.

  • Apps where users interact with each other

    Where users can see each other or send invitations or content, the stores generally expect reporting, blocking and in-app account deletion. We built all of these flows into Santra and released it on both stores.

  • Taking over an existing app

    The previous developer cannot be reached, nobody is sure who holds the store account, or the app no longer builds after the latest OS update. We first review the accounts, the code and the build process, then recommend in writing whether to continue with the existing code or rewrite it.

Not a fit

  • Showing website content inside an app

    If the app would do no more than display pages from your website, a mobile-friendly website is cheaper and needs no store review. Apple can reject apps that do no more than wrap a website for offering too little functionality.

  • 3D and action games that need a game engine

    Projects that call for an engine such as Unity or Unreal are outside what we do. We build interface-led games like Santra.

02Platform

Kotlin Multiplatform, React Native, native or a web app

We choose the technology before design starts, and the proposal says which option we recommend and why. Three things decide it most: how much the app relies on the phone’s features, who will maintain the code over the years, and whether a web version is needed.
  • Kotlin Multiplatform

    Kotlin · Kotlin Multiplatform

    When

    Business rules, the data layer and communication with the server are written once for both platforms; the screens are shared or built separately per platform, depending on the project. We choose it when the app relies heavily on device features such as the camera, Bluetooth or background work, or when Android developers will maintain the code later.

    The trade-off

    Whoever maintains the code needs to know Kotlin. If a library you want has no multiplatform version, that part is written separately for iOS and Android.

  • React Native

    React Native · TypeScript

    When

    Most of the screens and business logic run on both platforms from one codebase. We choose it when a web team will maintain the code later, or when the app will share code with a web project.

    The trade-off

    If there is no ready library for a device-specific feature, that part is written separately in Swift and Kotlin. Version upgrades of React Native and its libraries need regular maintenance.

  • Fully native (Swift and Kotlin)

    When

    If the app will ship on a single platform, or if features tied closely to the OS, such as widgets, a smartwatch app or heavy image processing, are at its core, two separate native apps can be the better answer.

    The trade-off

    Two platforms means two codebases: every feature is written twice and tested twice. If we recommend this route, the proposal states the reason and its effect on cost.

  • Web app (PWA)

    When

    When users will open it occasionally, being in the stores is not essential and few device features are needed. It runs in the browser and can be added to the home screen; it needs no store review or developer account, and updates go live immediately. In that case we build it as custom software.

    The trade-off

    It cannot be found by searching the stores. On iPhone, notifications and background work are more limited than in a native app.

03Deliverables

What a mobile app project delivers

The backend and panel items are in scope only when the app needs them.

01Planning and design

4 items
  1. Scope document: what is in the first release and what is left for later ones
  2. Screen flow map
  3. Clickable prototype you can try on your phone
  4. iOS and Android screen designs and source design files

02The app

5 items
  1. iOS and Android app and the release builds uploaded to the stores
  2. Sign-up, sign-in and password reset flows
  3. In-app account deletion
  4. Report and block flow (in apps where users send each other content)
  5. The complete source code, in a Git repository on your account

03Backend and admin panel

3 items
  1. Database and the API the app talks to
  2. Access rules: which user can read and write which data
  3. Admin panel for managing content, users and reports

04Store release

4 items
  1. App Store and Google Play listings: description, screenshots, category, age rating
  2. Privacy policy and support page at a live URL
  3. App Store privacy labels and the Google Play data safety form
  4. Demo account and review notes for the reviewer

05Handover

3 items
  1. Account and access list
  2. Written instructions for building a new version and submitting it to the stores
  3. Technical documentation: architecture, environment settings, third-party services used

04Process

The app development process and what each step produces

  1. 01

    Discovery

    We discuss whose problem the app solves, what is essential for the first release and what can wait. Any system to connect to, and any need for payments, maps or notifications, comes out at this step. The technology is chosen here too.

    Output

    Scope document and technology recommendation

  2. 02

    Screen flows and prototype

    We draw every screen and the transitions between them, and prepare a prototype you can tap through on your phone. Spotting a missing screen at this stage is far cheaper than spotting it after the code is written.

    Output

    Screen flow map and clickable prototype

  3. 03

    Design

    Once the prototype is approved, we produce the final screen designs. The visual language is shared across both platforms, while each platform’s own conventions, such as the back gesture, permission dialogs and the system typeface, are respected.

    Output

    Approved screen designs

  4. 04

    Development and test builds

    We build the app and, where needed, the backend. Interim builds reach your phone through TestFlight on iPhone and the Google Play internal testing track on Android, so you follow progress on a real device yourself.

    Output

    Test builds running on your phone

  5. 05

    Store preparation and review

    We prepare the store listings, privacy policy, support page and data-use declarations, and submit the app for review on both stores. If the review asks for changes, we make them and resubmit.

    Output

    App submitted for review; released once approved

  6. 06

    Handover

    We hand over the accounts, the source code and the release instructions. After launch, for the period written in the proposal, we monitor the crash reports in the store consoles and the user reviews, and fix the bugs that come up.

    Output

    Handover pack: access list, source code and release instructions

05Risks

Common problems in mobile app projects and how we prevent them

  • 01

    Rejection in store review

    The common reasons for rejection are knowable in advance: a privacy policy link that does not open, an account that can be created but not deleted inside the app, a flow where users can send each other content but cannot report or block, a demo account the reviewer cannot sign in with. We write these items into the scope during design. The store makes the approval decision; if changes are requested, we make them and resubmit.

  • 02

    Scope growing during development

    When a request arrives that is not in the scope document, we write down its effect on schedule and cost. You decide whether it goes into the first release or waits for the next.

  • 03

    An app left unmaintained after a new OS release

    The stores update their requirements over time; an app that targets an old Android version or is built with old development tools can run into restrictions when an update is submitted, or in how visible it is to new users. We write down who does the maintenance before handover. With written build instructions, another developer can take that work on too.

  • 04

    Data left unprotected on the server

    Data hidden in the app’s screens can still be read with a direct request if the server does not protect it. We define access rules at the database level. In Santra, row-level security (RLS) rules mean one player cannot read another player’s email, friend list or match details.

06Example

Apps we built and released

Both are on the App Store and Google Play, with Rufy Studio shown as the publisher on their store listings.
  • 01

    Santra

    A football trivia game played with new matches every day. Accounts with email and username, password reset, a leaderboard and level-based matchmaking, a friend list and match invitations, an offline mode for two people on one phone, reporting and blocking players, and permanent account deletion from inside the app. The backend runs on Supabase (PostgreSQL) in Frankfurt; a privacy policy and support page are published.

  • 02

    Aera Wallet

    A personal budgeting app for tracking spending and assets. Live on iOS and Android.

07Cost

What determines the cost of a mobile app

01Number of screens and flows
Cost depends most on the number of distinct screens and how complex the flows between them are. Screens every app has, such as sign-in, profile and settings, count too.
02Backend and features between users
Accounts or sync across devices mean the app needs a database and an API behind it. Friends, matchmaking, messaging, reporting and blocking create work in both the app and the backend; a panel for managing them is a separate work item.
03Integrations
Payments, in-app purchases, maps, push notifications or exchanging data with your existing system. Each one means its own tests and its own failure cases.
04Working offline
An app that keeps working without internet and syncs its data once the connection returns is more work than one that is always online.
05Costs that continue after launch
What budgets forget: Apple’s annual and Google’s one-time developer account fees; server and database hosting; email and notification services; maintenance after new OS versions. We list these separately in the proposal.

Once the scope is agreed in writing, we prepare an itemised proposal. Which post-launch maintenance tasks are covered, and for how long, is stated separately in the proposal.

08Ownership & handover

Who keeps the developer accounts, source code and data

The app is published under your company’s name, and when the project ends everything is under your control.

Handover list

App Store and Google Play developer accounts
Opened in your company’s name and billed to you; the store shows your company as the publisher. Opening an Apple account as an organisation requires a D-U-N-S number, and we guide you through the application. We are added to the accounts as team members.
Source code and design files
The full code sits in your account with its Git repository, and the design files are handed over. There is no licence or lock that stops you continuing with another developer.
Server, database and user data
Hosting accounts are opened in your company’s name and user data is held in them. We choose the server region together; Santra’s data is in the EU, in Frankfurt.
Signing keys and certificates
The signing keys and certificates needed to update the app are stored in your accounts and appear on the handover list. On Android, Google Play App Signing is used, so the app can still be updated even if the upload key is lost.

09FAQ

Questions people ask before commissioning a mobile app

01

What determines the cost of a mobile app?

Mostly the number of screens and flows, and whether a backend is needed; some costs continue after launch. All the factors are listed in the cost section on this page; once the scope is agreed in writing we give an itemised proposal.

02

How long does it take to build a mobile app?

Duration depends on the scope, the size of the backend, integrations, the number of approval rounds and store review. Review time is up to the store and grows if changes are requested. Projects usually run long because the scope grows during development, or because content and account details arrive late. With the proposal we give a step-by-step schedule that also states what is needed from you at each step.

03

Are the iOS and Android apps written separately?

In most projects, no. With Kotlin Multiplatform the business rules and data layer, and with React Native most of the screens as well, are written once for both platforms. Two apps are still built, submitted to each store separately and tested on their own devices. Where two separate native apps are the better answer, the proposal says so, with reasons.

04

Is the App Store and Google Play release included?

Yes. We prepare the store listings, screenshots, privacy policy, support page and data-use declarations, and submit the app for review on both stores.

05

Do you guarantee the app will be approved by the stores?

No; Apple and Google make the approval decision. We cover the common reasons for rejection in the scope from the start, and if changes are requested, we make them and resubmit.

06

Does the app need maintenance after launch?

Yes. New OS versions come out every year, the stores require updates to be built with current tools, and users report bugs. The proposal states separately which maintenance tasks are covered and for how long.

07

Who owns the app’s source code and developer accounts?

You do. The complete code sits in a Git repository on your account, and the developer accounts, signing keys and server accounts are in your company’s name, so the store shows you as the publisher. With the written build and release instructions, you can also continue the app with another developer.

08

Can you take over an existing app another team built?

Yes. We first check who holds the store accounts, signing keys and source code, and whether the app still builds with current tools. Then we recommend in writing whether it makes more sense to continue with the existing code or rewrite it.

09

Should I build an app or a mobile-friendly website?

An app, if users will open it often, if you need notifications, the camera or offline use, and if being in the stores matters. For a content-led service visited now and then, a mobile-friendly website or web app is cheaper, needs no store review and updates go live immediately. In the first conversation we tell you which one we recommend and why.

Rufy Studio

Tell us about your app idea or your existing app

Write whose problem the app solves, any system it needs to connect to, and the store link if you already have an app.