TIDESa civilization in progress

ArticleSoftware

Where the money goes in a software project (and how to avoid paying twice)

A plain account of what a client actually pays for in a software project, from the first conversation to the years after launch, and the handful of decisions that stop you paying for the same work twice.

Key points

  • Typing code is only one part of the bill. Understanding, design, testing, launch and upkeep are all real work.
  • Vague scope is the most expensive item in any project, and it never appears on the quote.
  • A low quote usually means something was left out, not that the same work is being done for less.
  • Agree in writing what "done" means before the work starts, not at the end.
  • The code, the domain and every account should be in your name from the first day.

1. A quote is a price for work nobody has seen yet

When you buy a fridge, you can look at it before you pay. Software is different. You agree a price for something that does not exist, described in a few paragraphs, and both sides imagine the result slightly differently.

That gap between two imaginations is where most of the money in a project is won or lost. The rest of this article walks through what the money is actually spent on, stage by stage, and then the decisions that keep the total under control.

2. Understanding the problem

The first thing you pay for is someone learning your business. A clinic that wants an appointment system has rules nobody has written down. Which doctor sits on which days. What happens when a patient arrives late. Who is allowed to cancel a booking, and whether the receptionist can override the system when a regular patient calls.

A developer who skips this stage will build the system they imagine a clinic needs. It will look right in the demo and fail in the first week of real use. Then the missing rules get added one by one, each as a change, each with a cost.

This stage produces very little that you can see. There is a document, some sketches and a list of questions. It still deserves to be paid for, because it is the cheapest place in the whole project to find a mistake.

3. Design

Design is two jobs. The visible one is how screens look and how a person moves through them. The invisible one is how the system is organised underneath: what information is stored, how the parts talk to each other, and what happens when two people change the same record at once.

Clients tend to judge the visible part and ignore the invisible part. That is natural, but the invisible part decides what future changes will cost. A school fee system designed around one campus can be painful to stretch to three. If a second campus is even a possibility, say so at this stage.

Changing a drawing takes an afternoon. Changing finished software that was built on the wrong drawing takes far longer. Approve the design carefully, because approval is the moment a cheap change becomes an expensive one.

4. Building

This is the stage everyone pictures: developers writing code. It is usually the largest single block of work, but it is a smaller share of the whole than most people expect.

A good part of building is the dull work you never see in a demo. What the screen shows when the internet drops. What happens when someone types a phone number into the name field. How a password gets reset. How an admin corrects a wrong entry without phoning the developer. A feature that works when everything goes right is perhaps half a feature.

5. Testing

Testing means trying to break the software on purpose before your customers break it by accident. Someone runs through every screen with wrong inputs, slow connections, old phones and two users acting at the same time.

This stage is the first to be cut when a quote has to come down, because its absence does not show on the day of delivery. It shows a month later, when a shop's billing screen gives the wrong total on a busy evening. By then the bug costs more to fix, and it has already cost you something with your customers.

Ask any developer who will test the work and how. A clear answer is a good sign. "We test as we go" is not an answer.

6. Launch

Finished software on a developer's laptop is not yet a working system. Launch is the work of putting it on a real server, connecting the domain, setting up backups, moving your existing data in, and making sure it stays up when real people arrive.

For a shop moving from a paper register or an old spreadsheet, the data move alone can be a serious task. Years of customer names are spelled three different ways. Stock items are duplicated. Somebody has to clean that up, and it is better to decide who before the project starts than on launch day.

Launch also includes people. Staff need to be shown the system, and someone needs to be reachable in the first days when the questions come.

7. The years after

Software is not a building that stands once it is finished. It sits on top of other things that keep changing: phone operating systems, browsers, payment providers, the server it runs on. When one of those changes, your software may need a small adjustment to keep working.

Maintenance is the name for this ongoing care. It is not a sign that the original work was poor. Over the full life of a system that stays in use, the upkeep often adds up to more than people planned for when they signed the first agreement.

  • Security updates to the tools and libraries the software is built on.
  • Fixes for problems that only appear under real use.
  • Hosting, domain renewal and backups, plus checking that the backups actually restore.
  • Small changes as your business changes: a new tax rule, a new branch, a new report.
  • Someone who answers when something stops working.

8. Why vague scope is the most expensive thing

Scope is the written description of what will be built. "A website with online ordering" is a vague scope. It does not say whether customers need accounts, whether there is delivery tracking, whether prices differ by area, or who updates the menu.

The developer has to price something, so they price their own guess. You approve it with a different picture in your head. Halfway through, the two pictures collide. Every gap then becomes a negotiation: is this part of the original job, or is it extra?

Both sides lose in that argument. You pay for changes you thought were included. The developer does unpaid work to keep the peace, then makes up the time by rushing something else. A clear scope costs a few extra days at the start and removes this whole category of expense.

  • List who will use the system and what each person must be able to do.
  • Write down what is deliberately not included in this version.
  • Name the devices it must work on and the languages it must support.
  • Agree how changes will be requested, priced and approved once work has begun.

9. Why the cheapest quote often costs more

Three quotes for the same project can differ widely. It is tempting to think the cheapest developer is simply more efficient. More often, the three developers are quoting three different projects.

A low quote usually leaves something out. The understanding stage is skipped. Testing is a quick look before delivery. Nobody has thought about the data move or about what happens after launch. None of that work disappears. It comes back later as a failure, as a change request, or as a second developer hired to repair the first one's work.

That last case is how people pay twice. The new developer often cannot build on what exists, because there is no documentation and the code was written in a hurry. So they start again, and the first payment bought only a lesson.

The fair way to compare quotes is to ask each developer what is included at every stage in this article. Only then are the prices comparable.

10. What "done" should mean

"Done" is a dangerous word because each side defines it in their own favour. To a developer under pressure, done can mean the features exist. To you, done means the business is running on the system without trouble.

Settle the definition in writing before the work starts. A sensible version looks like this.

  • Every item in the agreed scope works on the agreed devices.
  • The system is live on your own hosting and domain, not on the developer's test server.
  • Your real data is loaded and checked.
  • You hold the source code, the admin logins and a short written guide to running it.
  • A named period after launch is agreed, during which defects in the delivered work are fixed without a new invoice.

11. Who should own the code, the domain and the accounts

You should. This is the single cheapest protection in any project, and it is skipped all the time because it feels like paperwork.

The common mistake is letting the developer register the domain and the hosting in their own name "to save time". It works fine until the relationship ends. Then your website address, your customer data and your app store listing all belong, on paper, to someone who no longer works for you.

Register the domain, the hosting, the app store accounts, the payment gateway and the email service in your company's name with your company's email address. Give the developer access as a guest. Ask for the source code to be kept in a repository you own. If you ever change developers, you remove one person's access and add another's, and nothing has to be rebuilt.

A developer who is confident in their work has no reason to hold your accounts. Being easy to replace is part of doing the job properly.

12. How staged payments protect both sides

Paying everything in advance leaves the client with no leverage if the work stalls. Paying everything at the end leaves the developer carrying weeks of unpaid work for a client who may change their mind. Neither arrangement produces good software, because one side is always nervous.

Splitting the payment shares the risk. At TIDES, projects are paid half upfront and half on delivery. The first half means the client is committed and the team can give the project its full attention. The second half means the team has every reason to reach a real finish, not a nearly finished state.

A split like this only works when "delivery" has a definition. That is why the scope and the meaning of done matter so much. They are what the second payment is measured against.

13. A short checklist before you sign

None of this needs technical knowledge. It needs a few direct questions asked at the start, when asking them is free.

  • Is the scope written down, including what is left out?
  • Does the quote cover understanding, design, building, testing and launch, or only building?
  • Is "done" defined in a way both sides could check?
  • Are the domain, hosting, accounts and code in your name?
  • Is it clear what upkeep will be needed after launch, and who will do it?
  • Are payments tied to clear points in the work?

Learn to build this.

Four months, hands-on, in Lahore. Admissions are open.