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
A good fit
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.
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.
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.
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
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.
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 · 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 · 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.
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.
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
04Process
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
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
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
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
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
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
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.
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.
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.
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
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.
Mobile app
A personal budgeting app for tracking spending and assets. Live on iOS and Android.
Mobile app
07Cost
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
Handover list
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.
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.
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.
Yes. We prepare the store listings, screenshots, privacy policy, support page and data-use declarations, and submit the app for review on both 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.
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.
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.
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.
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
Write whose problem the app solves, any system it needs to connect to, and the store link if you already have an app.