When a software project goes wrong, it rarely fails because of the code. It fails because the people building it and the people using it pictured different things, and nobody noticed until late. Good planning is mostly about closing that gap early.
Here's what we ask every client to think about before a build, and the habits that keep projects calm once they start.
Before you talk to anyone
Write down the problem, not the solution
"We need an app" is a solution. "Our team spends two hours a day copying orders into three places" is a problem. Problems can be measured, prioritised and solved in more than one way, which gives you better options and better quotes.
Map how work actually flows today
Follow one order, job or customer from start to finish. Note every tool, every handover and every workaround. A rough sketch on paper is enough. This single exercise surfaces most of the requirements nobody thinks to mention.
Decide what success looks like
Pick two or three measures: hours saved, errors reduced, orders handled per person, days to get paid. They keep decisions focused when new ideas appear halfway through.
Gather what you already have
- Example spreadsheets, forms and documents your team uses.
- The tools you want to keep, such as accounting, email or WhatsApp.
- Who will use the system, and what each person needs to see or change.
- Any deadlines that genuinely matter, like a new branch opening.
How quotes and scope work
A fixed quote is only as good as the scope behind it. A good partner will want to understand your process before giving a number, and will write down what's included, what isn't, and what happens if things change.
| Vague scope | Clear scope | |
|---|---|---|
| Quote | A guess with a large buffer | Fixed and specific |
| Changes | Arguments about what was agreed | Priced and agreed before they're built |
| Timeline | Slips without explanation | Weekly progress you can see |
Habits that keep a build on track
- 1Weekly demos of working software, not slide decks or status reports.
- 2One decision maker on your side who can answer questions within a day.
- 3Real data early, so problems show up while they're cheap to fix.
- 4A short list of must haves, and a separate list for later.
- 5A pilot with a few users before rolling out to everyone.
What a healthy project rhythm looks like
Once the build starts, a calm project has a steady, predictable rhythm. Every week there's something new to try, a short list of questions for your team, and a clear note of what's coming next. Decisions are made in days, not weeks, and nothing important is discovered at the very end.
- 1Discovery: process mapped, scope written down, fixed quote agreed.
- 2Design: screens and flows reviewed with the people who will use them.
- 3Build: weekly releases on real data, with feedback after each one.
- 4Pilot: a small group uses the system for real work and reports issues.
- 5Launch: everyone switches over, with support close at hand for the first weeks.
Questions a good partner will ask you
You can learn a lot about a software partner from the questions they ask in the first meeting. Good ones focus on your business before technology:
- Who will use this every day, and what slows them down now?
- What happens to an order, job or customer from start to finish?
- Which tools must stay, and which would you happily retire?
- What would make this project a clear success in six months?
- Who on your side can make decisions quickly?
Red flags when choosing a partner
- A price before they understand how your business works.
- No working software to see until the very end.
- Vague answers about who owns the code and the data.
- Every change treated as a surprise, with no clear way to agree it.
- No plan for hosting, backups and support after launch.
None of these guarantees a bad project, but each one makes surprises more likely. It's always fair to ask about them before you sign.
After launch
Software is never finished, and that's a good thing. Plan for a care period where small fixes and improvements happen quickly, and agree how hosting, backups and support work. Then review the success measures you set at the start and decide on the next module.
Do this well and custom software stops feeling like a risky project and starts feeling like steady progress, one useful release at a time.