FAQ

Every Question We Get Asked About Building an App

Cost, timelines, native versus cross-platform, store submission, rejections, ownership and what happens after launch — answered the way we would answer them on a call, including the answers that are not in our commercial interest.

Getting Started

The First Conversation

What happens before anything is signed, and what we need from you to give you a number worth trusting.

What does the free quote actually include?

A call, then a written document. On the call we work out what the app has to do, who is going to use it and on which platforms, and what already exists. What comes back within two business days is a proposed scope for a first release, a native or cross-platform recommendation with the reasoning behind it, a week-by-week timeline that runs all the way through store review rather than stopping at “development complete”, and a cost range with the assumptions it rests on written down. It is free, there is nothing to sign, and the document is yours — if you take it to another studio and get a better price, that is a fair outcome.

How soon can you start?

Design usually begins within one to two weeks of an agreement being signed, and build work starts once the screens are approved. If your situation is urgent — a rejected submission, an app that has stopped working after an OS update, a developer who has disappeared with the signing keys — say so on the first call, because triage work can often start much sooner than a full build. If we genuinely do not have capacity we will tell you rather than accepting the project and quietly putting it in a queue.

What do you need from us before you can give a number?

Much less than people expect. A plain-language description of what the app should do, a rough sense of who uses it, which platforms you care about, and any integrations or compliance requirements you already know about. That is enough for a range. Sketches on paper, a competitor app you want to point at, or a feature list all help narrow it. You do not need a specification document — writing one without an engineer in the room usually means rewriting it later, and producing the scope is part of what we do.

Will you sign an NDA before we tell you the idea?

Yes, and there is a checkbox on the contact form to request one before any details are exchanged. We use a mutual NDA, so it binds both directions rather than only protecting one of us, and we are equally happy to sign your own document if your lawyer has one you prefer. Until it is in place, assume your first email is not yet protected and keep it to a one-line description — that is always enough to get the conversation started. The app ownership page explains what an NDA does and does not cover in more detail.

Choosing an Approach

Native, Cross-Platform, or Not an App at All

The decisions that get made before any code exists, and that are expensive to reverse afterwards.

Native or cross-platform — how do we decide?

The test is what the app leans on. If it is mostly screens, forms, lists, search and API calls — a booking app, a marketplace, a content app, an internal tool — cross-platform with React Native or Flutter usually wins, because one codebase covering both stores is meaningfully cheaper to build and far cheaper to maintain for years afterwards. Native Swift or Kotlin earns its extra cost when the hardware is the point: sustained camera work, Bluetooth peripherals, background location, heavy custom animation, large offline datasets, or platform features you want the week the OS ships. We build both, so the recommendation is not decided by what we would rather sell you.

Do we need both iOS and Android at launch, or can we start with one?

Starting with one platform is often the smarter move, and the question is where your users actually are rather than which platform is bigger globally. If you are testing an idea, one platform gets you real feedback for roughly two-thirds of the cost, and the second platform becomes a decision you make with evidence instead of a guess. Two situations argue for both at once: a consumer app where telling half your audience “not yet” kills the launch, and a cross-platform build where the marginal cost of the second store is small enough that splitting it makes little sense. We will tell you which case you are in.

Do we even need an app? Would a mobile website do the same job?

Sometimes it would, and we will say so. A responsive website is the better answer when the thing people do is occasional, when discovery happens through search, and when there is no reason for an icon to sit on a home screen — nobody installs an app to read your menu once. An app earns its place when you need repeat use and a home-screen habit, push notifications people actually want, camera or sensor access, meaningful offline behaviour, biometric sign-in, or performance a browser cannot reach. Asking someone to install software is a real request, and it has to be repaid in something the web genuinely cannot do.

Can you advise us without building it?

Yes. We take paid advisory work: reviewing an existing codebase and giving you a written verdict, sanity-checking a quote you have received from someone else, reviewing an app before you acquire the company that owns it, or working out whether your idea should be one app or two. It is charged as a fixed-price piece with a written output at the end, and the output is genuinely yours to act on however you like — including hiring a different studio. If the honest conclusion is that the current team should carry on, that is what the document will say.

If we go cross-platform, React Native or Flutter?

Both are mature and both ship real products, so this is rarely the decision that makes or breaks a project. React Native fits when your team already lives in JavaScript or TypeScript, when you are sharing logic with a web product, or when you depend on libraries with strong React Native support. Flutter fits when you want a highly custom, identical visual design on both platforms and tight control over rendering, because it draws its own widgets rather than wrapping the platform ones. The real question is who will maintain the app in three years, so we weight the answer towards whichever your future developers are more likely to know.

Building

What the Months in the Middle Look Like

How the work is organised, how you stay informed, and what happens when the plan changes.

How long does a mobile app take to build?

A focused first version is usually twelve to twenty weeks from kickoff to store approval. Roughly two to three weeks go on design and a clickable prototype, the bulk is build and testing on real devices, and the final stretch covers submission and any review feedback. Small, single-purpose apps can land faster. Anything with payments, real-time features, offline synchronisation, an admin panel or an integration with a system that was not built to be integrated with will run longer, and we would rather say twenty weeks and mean it than say eight and spend three months explaining why.

How do we see progress while you are building?

Three ways, all of them concrete. You get a short written update at the end of each working day covering what moved, what is next and anything blocking us. You get an installable build on your own phone roughly every two weeks, through TestFlight on iOS or a Play testing track on Android, so you can tap through the real thing rather than reading a percentage. And you get a call at each milestone. The two-week build is deliberately the centre of it — a status report can claim sixty per cent complete for a month, but an app on your phone cannot lie about whether the sign-up flow works.

What if we want to change something mid-build?

Expect to, and plan for it. Small changes — copy, layout, the order of a flow, an extra field — get absorbed as part of the normal work, because a project with no give in it produces an app nobody wanted. Anything that adds a screen, a new integration or a new piece of infrastructure gets a written note with the cost and the effect on the date before we touch it, and nothing starts until you agree. What we will not do is silently absorb a stream of additions until the timeline collapses and then explain it to you afterwards.

Who designs the app — do we need our own designer?

We design it, and that is inside the price rather than a separate line item. You get the user flows first, then the screens, then a clickable prototype you can tap through on a phone before production code is written — changing a flow at the prototype stage costs minutes and changing it after launch costs days. If you already have designs from someone else we are glad to build from them, but we will review them first and flag anything that will be awkward, expensive or non-standard on one of the platforms before quoting, because designs drawn without a platform in mind are where a lot of budget disappears.

Will you work alongside our existing developer or in-house team?

Yes, and it is common. We often take the mobile clients while an internal team owns the backend, or take over one platform while another team keeps the other. We will work to your repository conventions, your review process and your ticket system rather than imposing ours. What we ask for is a clear boundary about who owns which side of the API and one person who can settle a disagreement, because shared ownership with no boundary is how integration work turns into two teams pointing at each other while the release date passes.

Stores and Launch

Getting Past Apple and Google

Submission, rejection, accounts and rollout — the stage where most first-time app projects discover something nobody mentioned.

Do you handle App Store and Play Store submission?

Yes, end to end, and it is part of the build rather than an extra. That covers setting up the developer accounts in your company name, signing certificates and provisioning, the store listings and their descriptions, screenshots at the required device sizes, age ratings, the privacy and data-safety declarations both stores now require, export compliance answers, a demo account for the reviewer, and responding to review feedback until the app is live. Handing a client a binary and wishing them luck is where a lot of first submissions die.

What happens if Apple or Google rejects the app?

We fix it and resubmit, and it is not billed to you when the rejection relates to work we did. Rejections are normal rather than catastrophic — the common causes are a permission string that does not explain why the app needs access, a reviewer unable to get past a sign-in wall, a subscription screen missing a required disclosure, metadata promising something the build does not do, or a crash on the reviewer’s device. Because we design around that list from the start, the rejections we do see are usually answered with a clarifying note or a metadata change rather than with new code.

Who owns the Apple and Google developer accounts?

You do, from the first week. We create both accounts in your company name with you as the legal account holder, and we are added as a member with the access needed to do the work. Apple and Google bill you directly on their own renewal cycles. The reason this matters is that an agency-owned account makes your app an asset on somebody else’s balance sheet: if the relationship ends badly you can lose your listing, your reviews, your ratings history and your ability to ship an update, all at once. We remove that risk by never creating it.

Can you publish the app under our existing developer account?

Yes, and that is usually the better option if you already have one, because your existing account may carry reviews, ratings history and a user base worth keeping. We ask to be added as a member with a defined role rather than being handed the account holder credentials — you keep the two-factor authentication on your own device, you can see exactly what we have access to, and you can remove it in one click. If your account is currently held by a previous agency, we can walk you through getting the app transferred into an account you control before anything else starts.

Do you do a phased rollout, or does everyone get the update at once?

Phased, wherever the platform allows it. On Android we start a release at a small percentage of users and step it up while watching the crash-free rate and the vitals, and we can halt a rollout mid-way if something is wrong — which is the closest thing mobile has to an undo button. iOS offers a phased release for updates over a number of days, and we use it. This matters more on mobile than anywhere else: a bad web deploy is reversed in minutes, whereas a bad app release is already installed on people’s phones and can only be corrected by shipping another build and waiting for them to take it.

Cost

What You Pay and When

Ranges, what sits inside the number, what sits outside it, and how the money is staged.

What does a mobile app typically cost?

Most first versions land somewhere between roughly $12,000 and $70,000 in US dollars. What moves the figure is the number of distinct screens, whether you need one platform or two, and whether the app includes the genuinely expensive pieces: payments and subscriptions, real-time features, offline synchronisation, an admin panel, a custom backend, or an integration with a system that was never designed to be integrated with. The cost estimator on this site gives an indicative range in about a minute, and a real figure follows a scoping call. A number quoted before anyone understands the scope is a guess in a suit.

What is included in that price?

Scoping and technical planning, all the UI and UX design work and the clickable prototype, development, testing on a real spread of devices rather than only a simulator, store listing preparation with screenshots and declarations, submission to both stores and handling review feedback, the source code and handover documentation, and a defect-fix window after launch. The daily written updates and the two-weekly installable builds are part of the engagement, not billed separately. Anything we intend to exclude is written into the proposal, where you can see it before signing rather than discover it on an invoice.

What is deliberately not included?

The things we do not control and would only be marking up. Apple and Google developer account fees are billed to you directly, because the accounts are in your name. So are paid third-party services the app depends on — maps, SMS, push infrastructure beyond a free tier, payment processing, error reporting at scale — along with cloud hosting for any backend, domain names, stock photography or icon licences, and any content, translation or legal copy you need written. We list the ones your app will actually need, with realistic figures, before you commit to them.

What does the payment schedule look like?

Fixed-price builds are staged against milestones rather than against the calendar: a deposit to start and reserve the team, a payment when the designs and prototype are signed off, one or two payments tied to agreed build milestones, and a final payment on store submission. Intellectual property transfers to you on that final payment. Retainers are billed monthly in advance. We do not ask for the whole amount up front, and you should be cautious of anyone who does — staged payments are what keeps both sides motivated to reach the next milestone.

Do you work hourly, or on a monthly team basis?

For a defined first release we prefer fixed price, because you get budget certainty and we carry the risk of having estimated badly — which is the correct way round, since we are the ones doing the estimating. For continuing work after launch a monthly retainer fits better, since the roadmap genuinely changes and pricing each small change individually wastes more time than it saves. Pure hourly billing is available for advisory work and short investigations, but for a build it tends to reward slowness, and neither of us wants that incentive in the contract.

After Launch

The Part That Never Finishes

What happens to an app once it is live, who keeps it working, and what you are left holding if we part ways.

What actually breaks after an app launches?

Usually nothing you did. Both platforms ship a major OS release every year that retires APIs, changes permissions and alters how screens are drawn. New handsets arrive with new sizes and aspect ratios that your layout was never tested against. Signing certificates, provisioning profiles and push keys expire on dates nobody wrote down. Store policies change with compliance deadlines attached, and Google raises the minimum target API level each year. Third-party libraries get abandoned or publish breaking versions. An app left completely alone typically starts failing for real users somewhere between twelve and eighteen months in.

Do we have to take a support plan?

No, it is never a condition of the build, and a small app with a patient audience can reasonably be looked at once or twice a year instead. What we will not do is let you believe an app is finished at launch. If you skip a plan, budget for a compatibility release around each annual OS launch, keep a calendar entry for every certificate and key expiry, and watch your crash reports. If none of that is going to happen in practice, a retainer is cheaper than the emergency it prevents — the support plans page sets out the bands and what each covers.

How do updates work once the app is live?

Every change, however small, has to go through a new build and a store review before a single user sees it, and then those users have to actually install it. That is the structural difference between mobile and the web, and it shapes everything: fixes get batched into planned releases rather than shipped one at a time, anything configurable is made remotely adjustable so it can be changed without a release, and the app is built to stay compatible with older versions of your backend, because a meaningful share of your users will still be on last month’s build for months.

Who owns the code, and what happens if we stop working together?

You own it. The repository is in your organisation from the first commit, the developer accounts are in your company name from week one, and full intellectual property in everything built for you transfers on final payment. If we stop working together, there is nothing for us to hand back because you already hold it — we do a handover instead: a written state-of-the-app note, the build and release documentation, confirmation of where the signing keys live, a list of every third-party service and what it costs, and our access removed once you are ready. No hostage-taking, no exit fee.

Your Question Not on This Page?

Ask it directly. Anything you raise gets a reply within one business day, and we would much rather answer an awkward question now than after you have signed something.