TryGTM is live.See it

Write down what done looks like before the software project starts

7 min read

By Lumina Software

  • Custom software
  • Project planning
  • Operations
  • Small business

A roofing company hires a developer to build a simple tool. The office wants a screen where the estimator can enter measurements, pick materials, and print a quote. Six weeks later the developer says it is finished. The owner opens it and asks where the button is that emails the quote to the customer. The developer says nobody asked for that. The owner says it was obvious.

Both of them are telling the truth. The project never had a written answer to one plain question: how will we know this is done?

Most software projects that go sideways for small and mid sized businesses do not fail because the code is bad. They fail because the person paying and the person building had two different pictures of the finished thing, and nobody wrote either picture down. This post is about writing it down before the work starts, in a form a busy owner can produce in an afternoon.

Why "build me a quoting tool" is not enough

A short request feels clear to the person who wrote it because they fill in the gaps from years of running the business. They know quotes go out by email. They know the estimator works from a tablet in a truck. They know the price list changes every spring and that two of the materials are only sold to commercial jobs.

The developer knows none of that. They will fill the same gaps with their own guesses, and their guesses will be reasonable and wrong. The result is a tool that works on the developer's laptop and does not fit the way the office actually runs.

The fix is not a long specification document. A 40 page spec is just as easy to misread, and nobody keeps it current. What works better is a short list of checks that a person can walk through on the finished software and answer yes or no.

Write the checks as things a person does

Each check should describe a real person doing a real task with the software, and what they should see at the end. Keep them concrete enough that two people would agree on whether it passed.

Here is what a weak check and a strong check look like for the same roofing tool:

  • Weak: "The tool should generate quotes."
  • Strong: "The estimator enters a roof of 28 squares with architectural shingles on a tablet, taps send, and the customer receives a PDF quote by email within two minutes with the company logo and the correct total."

The strong version settles a lot of questions without anyone arguing about them. It runs on a tablet. It sends email. It produces a PDF. It uses the logo. The total has to be right, which means someone has to say what right is.

A good list for a small tool usually has 10 to 25 checks like that. If you are past 50, the project is probably two projects.

Start with the jobs people do every day

The easiest way to build the list is to sit with the people who will use the software and write down what they do in a normal week. For each task, write one check.

For a field service office, that might look like:

  • The dispatcher moves a job from Tuesday to Thursday and the assigned tech sees the change on their phone without refreshing.
  • The office manager searches by the customer's phone number and finds the account even when it was entered with dashes or a country code.
  • A tech marks a job complete with a photo while they have no signal, and it shows up in the office once the phone reconnects.
  • The owner pulls a list of every unpaid invoice older than 30 days and exports it to a spreadsheet.

Notice that none of these say how to build anything. They do not mention databases, frameworks, or screens. They describe the result the business needs. That leaves the developer free to choose the method and makes it obvious when the result is missing.

Write down the bad days too

The checks that save the most money are the ones about things going wrong, because those are the ones nobody thinks to mention. Ask a few questions for every daily task:

  • What happens if someone enters it twice?
  • What happens if the internet drops halfway through?
  • What happens if two people edit the same record at the same time?
  • What happens if the customer's email bounces?
  • Who is allowed to do this, and who should be blocked?

Each answer becomes another check. "If the estimator taps send twice, the customer gets one email, not two" is a sentence that takes ten seconds to write and can prevent a week of cleanup after launch.

Permissions belong on this list. If the front desk should not see payroll, or a technician should not be able to delete an invoice, say so in a check that someone will actually test by logging in as that person.

Say what is out of scope

A list of what the software will not do is as useful as the list of what it will. It stops the slow drift where every review meeting adds one more small request until the timeline has doubled.

Keep it short and specific:

  • No customer login in this version.
  • No integration with the accounting system yet. Quotes are exported, not synced.
  • English only.

Out of scope does not mean never. It means not in this project, and it gives everyone a clean place to park good ideas for the next round.

Agree on who checks and when

A list nobody runs is just paperwork. Before the work starts, agree on three things:

  • Who walks through the checks. It should be someone who does the job every day, not only the owner and not only the developer.
  • What device and data they use. Test on the tablets the estimators actually carry, with a copy of real prices and a few real customer records, not a laptop with sample data.
  • When it happens. Run the list at each milestone, not only at the end. Finding a missing email button in week two is cheap. Finding it in week six is an argument.

When a check fails, the conversation becomes simple. Either the software is wrong and gets fixed, or the check was wrong and gets rewritten with both sides agreeing to the change. Either way, nobody is relying on memory of a phone call from a month ago.

Keep the list after launch

The same list is useful long after the project ships. When the software gets an update, someone can run the checks again and confirm the daily work still works. When a new person joins the office, the list doubles as a plain description of what the tool is supposed to do. When you hire a different developer later, it tells them what they must not break.

Store it somewhere everyone can find it, next to the login details and the vendor contact, and update it every time a check is added or changed.

A one afternoon version

If this all sounds like too much, here is the smallest useful version:

  1. List the five tasks people will do most often with the new software.
  2. Write one check for each, describing a person, a device, an action, and the result they should see.
  3. Write one check for the most likely way each task goes wrong.
  4. Write three things that are out of scope.
  5. Name the person who will run the checks and the date of the first run.

That is about 15 lines. It will not catch everything, but it turns "it was obvious" into something both sides can read, point to, and test. That is usually the difference between a project that lands and one that ends with an awkward meeting about a missing button.

Written by Lumina Software. Have a question? Book a call

Keep reading