Nearly every first call starts with the same question, and it is never phrased as a question. It arrives after ten minutes of talking about the app: "So how does payment work?" What the person means is "how do I hand money to someone I met last Tuesday and still be able to walk away?"
Fair question. I have been on both ends of it, as the person hiring and the person building.
The three shapes people usually propose
All up front. A developer asks for the whole amount before starting; a client offers it to get a discount. Both are bad ideas, in opposite directions. The client's only leverage after the transfer is a polite WhatsApp message.
Fifty-fifty. The most common proposal, and it is better than nothing, but it puts the milestone in the wrong place. The first half of a build is the part everyone enjoys: screens, the flow, the thing that made the idea feel worth doing. The second half is the ugly part that takes more days than it should — and the client only finds out how ugly during delivery, with half the money already gone.
Hourly. Fine for maintenance, wrong for an app that has to reach a specific point. It rewards the work that is easy to measure, and the work that decides whether the app survives — permissions, payments, deployment, the odd failure path — is exactly the part nobody wants to be the slow billable hour.
What I do instead
Four steps, and only one of them involves money before anything exists.
1. The scope conversation is free and it is not a sales call. We spend it on the ugly questions: who signs in, who pays and through what, what happens when the same record is edited by two people, where the data lives, who owns the domain. At the end there is a written scope — a page, not a proposal deck — and a price. If the price is wrong for you, we stop there and it cost you nothing. On my side that is deliberate: the number should be a decision, not a negotiation tactic.
2. The deposit buys the first day or two of work, not the whole project. It is small enough that losing it would annoy you but not hurt you, and large enough that I am not working for free on a maybe. What it buys is defined in the same sentence: the first working flow, on your own accounts.
3. A walkthrough before the second payment. This is the step that replaces trust with evidence. Before any more money moves, you get a link that opens on a throwaway dataset and you click through it yourself, with your own phone, your own badly-typed email. Not a video of me clicking. Not screenshots. If what you see does not match the scope, we fix it or we stop, and stopping at that point does not require a lawyer.
4. The balance moves when the accounts move. The last payment is triggered by handover, not by a promise: source code in a repository you own, the database and hosting under your billing account, the domain registrar in your name, and — the one people forget — the store seller account applications, which take longer than the app did.
The part people forget to write down
Two sentences in the scope prevent most of the arguments I have seen:
- What is not included. "Shipped to the App Store" and "works on Android" are different promises. So are "payments work" and "payments work in your country with your business registration".
- What happens if it stops. If you stop, what you have paid for is yours, in the state it is in, and I hand over what exists. If I stop, you get the same thing and the deposit for unstarted work goes back. This sounds morbid to write on day one and it is the reason day twenty is calm.
Red flags, from both sides of the table
On the developer's side: anyone who wants everything up front, anyone who cannot issue an invoice from a real company, anyone whose price is a range that only narrows after you have paid, and anyone who will not name the person who will actually write the code.
On the client's side: "we will pay when the app is live and making money" (that is a co-founder offer, not a contract), a scope that exists only in a chat thread, and a project that is "basically finished, just needs a few things" where nobody can list the few things. That last one is not a payment problem, it is a scoping problem, and it is the most common way a rescue job turns into an argument about whose fault the delay was.
Why the timeline makes this easier than it sounds
A three-month project cannot be paid this way, because too much happens between milestones. A three-to-five day build can, and that is most of the reason the timeline is short: the shorter the build, the smaller the bet at every step, and the sooner you are clicking a real link instead of imagining one.
I build these as a one-person studio in Seoul — you talk to the person writing the code, the scope call is free, and nothing is due before there is a contract. If you have an app sitting at 80% and are trying to figure out whether a second person can finish it, that first conversation is the cheap way to find out.
- Studio (English): https://cpcai-studio.netlify.app/en/
- Japanese: https://cpcai-studio.netlify.app/ja/
- Email: yyhak12345@gmail.com
Top comments (1)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.