Services · One app, run properly

iOS and Android apps, built in Tbilisi from one codebase.

One React Native codebase for both phones, the backend that actually makes an app work, and a release process that lets us fix something on a Tuesday. We have built one app. It is ours, we still run it, and everything here is drawn from it.

iOS + Android
One codebase, plus native modules we wrote ourselves
23
Screens drawn and clickable before a line of app code
Day one
Apple, Google and the repository in your name
The part other studios leave out

One app. Ours. Shown with its limits.

Most app pages open with a wall of phone mockups and a number — fifty apps, a hundred apps. We have one. It is called Relive, we designed and built it, we own it, and it is live in Georgia at relive.ge with real weddings and real trips inside it.

The native iOS and Android builds are made and in testing. The store listings are the step still open, and the honest reason is a queue of account paperwork on our side rather than a technical wall. We would rather you read that here than find it out on your phone during our meeting.

So this page does not show you a count. It shows you the working: what an app is actually made of, how ours is put together, and what happens the week after launch when something is wrong. Everything on it is drawn from a product we still run.

Before anything else

You may not need an app.

Sixty seconds. Tick what is true of your case — nothing is sent anywhere, and the answer is yours to keep even if it sends you somewhere other than us.

Nothing ticked yet

Answer honestly and it will tell you.

Most projects that arrive asking for an app tick two of these. That is not a bad outcome — it usually means the thing you want exists faster, cheaper and in more hands as a website.

The reframe

Every problem below has a line opposite it.

Your site today

You were handed a zip file.

Delivery meant a folder and a password. Nobody can tell you what changed, or when, or why.

A repository in your organisation.

From the first commit, not at handover. You watch it being built rather than receiving it at the end.

Every fix means a store release.

A typo takes a week, because it takes a build, a review and a rollout before anyone sees it.

Two release lanes, agreed up front.

Interface and logic fixes reach people in hours. Only native changes go through review.

It works on the developer's phone.

Background uploads, notifications and permissions behave differently on real devices, and that is where it breaks.

Tested on the hardware the OS gates.

Camera, photo library, push, background work and payments checked on real phones, not a simulator.

The store accounts are in someone's personal email.

A developer leaves, and you cannot ship an update to your own app.

Accounts in your company's name.

Apple and Google opened on your legal entity, with our access added rather than the reverse.

Nobody knew it was down.

You find out from a customer, because nothing was watching and no one owned the answer.

It tells us before it tells you.

Crash reporting and health checks from day one, with the previous build kept installable so a rollback is a decision, not a rebuild.

Discovery decides whether you need an app at all — and we will say so if you do not.

Priced per phase, so a first version can prove the demand before the rest is committed.

Store accounts opened in your company's name in week one, not month four.

Why the quotes differ by ten times

An app is eight things. Most quotes cost one of them.

When two quotes for the same app differ by ten times, they are almost never quoting the same eight things. Ask which of these are in scope, and the difference usually explains itself.

After it is live

How a fix reaches your users on a Tuesday.

The question nobody asks until the week after launch, when something is wrong and the answer turns out to be “wait for Apple”. It does not have to be.

Lane A  ·  Over the airHours

Interface and logic fixes

A wrong label, a broken layout, a rule that fires at the wrong moment. The JavaScript and assets are replaced on devices that already have the app, tied to a runtime version so an update can never land on a build it was not written for.

  • Copy and layout
  • Business rules
  • Most bugs you will report

No store review.

Lane B  ·  New binaryDays to weeks

Anything touching native code

A new permission, a new library, a new payment path, a change to what the app is for. This is a real build, a real submission and a real review, on both stores, with a staged rollout so a bad release reaches a fraction of people rather than all of them.

  • New permissions
  • New native modules
  • Store-facing changes

Review, then staged rollout.

The rule that makes it safe

Native modules are fenced. An update that lands on an older build must degrade, never crash.

Apple’s developer terms permit over-the-air updates provided they do not change what the app is for. That is the boundary between the two lanes, and it is a rule we hold ourselves to rather than a feature of the tooling.

Checked before every rollout widens
  • Crash-free rate read before the rollout widens, not after
  • Release notes written for the person who has to support it
  • Previous build kept installable, so a rollback is a decision not a rebuild
  • Anything that changed the database checked against the oldest build still live
Spec sheet

What ships, in numbers.

First website? This is the standard every build is measured against before we hand it over — the same one whether the job is a landing page or a platform.

90+

Lighthouse, mobile

The target every build ships against, verified before launch — not a promise you have to take on trust.

Performance
Sub-second first loadLighthouse 90+ on mobile, checked before launch
Design fidelity
Pixel-exact, every breakpointPhone, tablet, laptop, wide — not approximately
Motion
60fps, GPU-compositedNo jank, no layout shift, reduced-motion respected
Accessibility
WCAG AA contrastFull keyboard path and screen-reader labels
Browsers
Last two versionsSafari, Chrome, Firefox, Edge — plus real iOS devices
Languages
GE / EN / RULocalised routes and metadata, not a translate widget
Search
Schema, sitemap, metadataStructured so answer engines can quote you
Ownership
Yours on day oneCode, CMS and domain in your accounts, not ours
How it works

Eight steps, no surprises.

The full process
  1. 01

    Intro call

    Thirty minutes. A straight answer and a budget range.

  2. 02

    Discovery

    We map the problem and write the scope.

  3. 03

    Design & build

    Weekly demos, a staging link from week one.

  4. 04

    Launch & after

    Live, tracked, and still ours to look after.

Shipped with
FAQ

Asked and answered.

Still unclear? The intro call costs thirty minutes and commits you to nothing.

Not from the public stores yet, and we would rather tell you here than have you find out on your phone during our meeting. Relive is our own product: it runs in production on the web at relive.ge, and its iOS and Android builds are made and in testing. The store listings are the step still open, and the reason is account paperwork on our side rather than a technical wall. Ask us and we will open it on a phone in front of you.

Because it is one we operate rather than one we delivered and forgot, and operating is where the lessons are. Carrying a single product all the way through means we have already met the parts nobody demos: store paperwork, payments that behave differently outside the sandbox, video processing that stalls on one bad file and blocks everything queued behind it, and finding out something is down. A studio that has shipped ten apps and run none of them has not met any of that.

Often a website does, and the fit test near the top of this page is there to help you decide. If what you are offering is content, a catalogue, a booking form or a one-off purchase, a fast mobile web build does the same job with no install to ask for and no store to satisfy — and search engines can read it, which an app cannot. An app earns itself when people return without being reminded, or when you need the camera, offline state, background work or push notifications.

You do, from the first commit rather than at handover. The repository is created in your organisation, the Apple Developer and Google Play accounts are opened on your company's legal entity rather than an employee's personal email, and the database and file storage sit in your accounts with our access added rather than the reverse. Without a written assignment, the default legal position in most places is that the people who wrote the code own it — so we put it in the contract.

Assume at least one round. Rejection is routine rather than a disaster, and we absorb the first round in the fee rather than billing it back. Apple publishes that it reviews the large majority of submissions within a day and names plain incompleteness as the dominant cause of trouble — crashes, placeholder text, dead links, a privacy policy that does not match what the app actually collects. The way to avoid a second round is to have the paperwork honest the first time.

For personal developer accounts opened after November 2023, yes: Google requires twelve testers, opted in and staying opted in for fourteen continuous days, before you may even apply for production. Registering as an organisation rather than as a person avoids the requirement entirely, which is the first thing to settle — in week one, not in month four. We know this one from the inside: it is the step still open on our own app.

Not for most bugs. React Native apps can receive JavaScript and asset updates over the air, and Apple's developer terms permit this provided the update does not change what the app is for — so an interface or logic bug can reach everyone in hours. Anything touching native code still needs a build and a review. The rule that makes the two safe together is that native modules are fenced, and an update landing on an older build must degrade rather than crash.

For most business apps, yes, and it is the honest default. We build on React Native with Expo — one codebase, both phones, close enough to native that your users will not notice. Where cross-platform is said to fall down is exactly where it does not have to: when you need something genuinely native, you write it. Our own app has a real iOS Live Activity written in Swift and a real Android foreground service written in Kotlin, sitting inside the shared codebase.

Not the number of screens, which is the weakest predictor and the one buyers quote first. The cost sits in how many kinds of user the app has, whether it needs a backend of its own or can talk to something you already run, how much of the phone it touches — camera, media library, push, background upload, offline — and whether money changes hands inside it. Payments are the most reliable way to double a mobile budget. The eight layers above are the honest checklist.

You will hold a build long before you have a launch date. Plan roughly three to five months from kickoff to a first usable version, plus store submission on top: about a month of discovery and design, two to three months of build with a testable build in your hands every week or two, then the tail nobody budgets for — device testing, privacy declarations, age ratings and store paperwork. Anything quoted at six weeks is either much smaller than you think or leaving out the tail.

The industry convention is fifteen to twenty per cent of the build per year in steady state, and more in the first year while real usage finds what testing did not. That is separate from new features. It covers the annual iOS and Android releases, dependency upgrades that arrive whether you want them or not, expiring certificates and signing keys, store policy changes, crash triage, and the running bill for servers, media storage and messaging.

Yes, and not as a translation layer bolted on afterwards. Our own product ships Georgian and English throughout — the app, the web product and the admin copy — with a written Georgian review as part of the work rather than a machine pass. Georgian typography breaks in specific, predictable ways when a layout was drawn in English, so the screens are designed with the longer language in them from the start.

Start a project

Tell us what you are building.

Thirty minutes, no pitch deck. Describe the problem and we will tell you what it takes to solve it — scope, budget range, timeline — even if the answer is that you do not need us.

Phone (optional)
What are you building?

We reply within 24 hours.