1. When custom software makes sense
Custom software makes sense when the process you want to support is specific to your business and standard products force you to change it. This often happens with quotes built on particular rules, approvals tied to your organisation, or data that must interact with other systems already in use. It is not the right choice for every need. If an existing product covers the main part of the work and the rest is handled through a few manual steps, it is often better to configure it more fully before developing anything new.
Before starting a project, describe today's problem in concrete terms: time lost in repeated steps, data entry errors, information reaching the manager too late. If you cannot explain it in a few lines, the supplier will build something different from what you need. Basic choices, such as comparing low-code with bespoke development or modernising a legacy management system, merit dedicated guides and should be made before you sign a quote.
2. The phases of the project
A custom project almost always goes through the same phases: analysis, specifications, prototype, development, testing, release and maintenance. Each phase must produce a written document and have an internal person who approves it. When a phase is skipped, the problem returns later, usually at greater cost: a requirement forgotten during analysis becomes a change during testing and a rework in production.
Ask the supplier for the phased plan before signing the contract. Each phase must state what is delivered, who approves it and what happens if approval does not arrive. In practice, a good plan links each deliverable to a decision: you are approving a prototype, a set of functions, a test result. Without this link, the next phase starts on uncertain foundations and the project becomes hard to govern.
- Analysis of the problem and of current processes, with a designated internal owner.
- Written functional specifications, approved before the final quote.
- Clickable prototype to verify that the logic is right.
- Development in short iterations, each closed with a demonstration.
- Acceptance testing with real users and criteria defined in advance.
- Controlled release, with a trial migration and a rollback plan.
- Maintenance and evolution governed by a support contract.
3. Preparing the requirement before the quote
The quality of the quote depends on the document you provide. It does not need to be voluminous: you need a description of the processes, the list of users who carry them out, the data that goes in and comes out, the systems the software must talk to, and the rules that cannot be changed, such as tax deadlines or mandatory approvals. Also describe what the software must not do. Boundaries remove ambiguity and reduce later change requests. An incomplete document is a risk that falls entirely on you, not on the supplier.
The full technical detail is written later, together with the supplier, as a specifications document. The initial quote only needs a clear scope that someone who is not technical can read. The dedicated guide on writing specifications explains how to turn this scope into requirements that developers understand without calling you every day, and how to check that they are complete. The scope must be signed by the internal owner, not only by the supplier.
4. Choosing the supplier and the contract
The supplier should be assessed more on method and verifiable references than on the lowest price. Ask how they work: whether they use iterations with periodic demonstrations, who will be the project manager, how they handle changes to scope and how they document the code. A supplier who promises everything without asking questions is telling you they will ask less than the project requires. Ask for examples of similar projects they have already delivered.
The contract must set out in writing the phases, the acceptance criteria, the change procedure and ownership of the code. On the last point a legal review is advisable, because standard clauses often do not cover components the supplier reuses. The detail is in the dedicated guide on code ownership and licences. The clause on changes to scope is the one most often left out.
| Aspect | What to ask | Warning sign |
|---|---|---|
| Working method | How iterations and demonstrations are organised | A single lump-sum quote with no phases |
| Responsibility | Who the project manager is and who decides on changes | A single sales contact and no visible technical staff |
| Code ownership | Who owns the code and with what usage rights | Vague clauses or unspecified licences |
| Security | How they manage access, secrets and security testing | Generic answers with no concrete examples |
| Continuity | What happens if the supplier stops trading | Code kept only on the supplier's systems |
5. Development and change control
The most common risk during development is that the software becomes different from what was approved without anyone noticing. To prevent this, each iteration should close with a demonstration on test data and a simple record: what was done, what remains open and what changed compared with the specifications. The record is the document that lets you decide without being technical. A short but signed record is worth more than an undocumented meeting.
Change requests must be managed under a precise rule. A change that alters costs or dates must be assessed in writing and approved by whoever has decision-making authority. Small requests can go into the next iteration. Without this discipline the project grows longer, the budget is used up and the visible result always arrives one step later. A change without a record is one that nobody will be able to reconstruct.
- Demonstration at the end of each iteration with real users, not only with the supplier.
- Change log with date, reason and impact on cost and timing.
- Test environment separate from production, with fictitious or anonymised data.
- Progress record shared with the internal owner.
6. Testing and release to production
Acceptance testing is the moment you decide whether the software is ready. It must be conducted with the people who will use it, following scenarios written in advance: an order from entry to invoicing, a case from opening to closing, a return of goods. Each scenario has an expected outcome, and every deviation is recorded with a severity rating. The person who approves the test should not be the person who wrote the code. Whoever signs must know what they are accepting, not just that the work is finished.
Release must be planned as an operation with a rollback plan. Verify the data migration on a copy, make a backup before the switch and establish in advance who decides whether to return to the previous version. The longest and most delicate part is often the clean-up of master data, which has its own dedicated guide. The rollback plan must be tested at least once before the actual switch.
7. After release: maintenance and evolution
Software does not end at release. It needs fixes for faults, updates to the libraries and the system it runs on, adaptations when connected systems or regulations change, and new features. Distinguish from the outset between corrective maintenance, meaning fixing problems, and evolutive maintenance, meaning new functions. These are two items with different cost logics and should be negotiated separately. Poorly defined maintenance becomes the most frequent point of conflict.
Ask how security updates are handled, who responds when something stops working and within what indicative timeframes. The cost depends on scope and complexity, so do not compare it with a standard product subscription without first clarifying what it includes. The guide on evolutive maintenance explains how to read these items. Also agree who responds to faults outside working hours.
8. How to start this week
The first step is a page describing the problem, the users, the data and the systems involved. Involve the people who do the work every day, not only management, because they often know best where time is lost. This page becomes the basis for quotes and for comparing suppliers, and it stops you from choosing on the strength of a sales demo alone.
Then read, in this order, the guides on specifications, integration with existing systems and testing: these are the areas where projects lose the most time. Talk to a few suppliers and ask how they would work on your case. If you want an opinion on the scope before deciding, contact us: the first conversation is there to establish whether the project really is bespoke or whether a configuration will do.
Frequently Asked Questions
How long does a custom software project take?
It depends on the scope, the number of integrations with other systems and the availability of internal owners, which is often the real constraint. A small tool with clear processes can take very different time from a management system touching several departments. Ask the supplier for a phased plan with dates linked to approvals, not a single final deadline.
Do I need an internal technical person to commission the software?
Not necessarily a programmer, but you do need an internal person who knows the process and can make decisions. The client-side owner is often more important than the development team, because late decisions cost more than the code. If nobody in the company can approve deliveries, the project stalls at the first test.
How do I choose between a standard product and custom software?
Compare the process you want to support with the functions of available products. If the differences concern a few steps, it is often best to configure the product and adapt your processes a little. If the difference concerns the core of how you work, custom software becomes the more sensible option. Also assess licence and maintenance costs over the medium term, not just the initial quote.
Who owns the code at the end of the project?
It depends on the contract. This must be settled in writing before development begins: usage rights, code ownership, third-party libraries and documentation. It is a matter to have checked by a lawyer, because standard clauses do not always cover the case of a supplier who reuses its own components.
Can I change my mind during development?
Yes, changes are normal in a real project. However, they must be recorded, assessed for their impact on cost and timing, and approved by whoever decides. Without this rule every request seems small, and the final result ends up far from what was approved. A simple procedure avoids most of the arguments at the end of a project.
What happens if the supplier stops trading?
The risk is reduced by asking from the outset for the source code with its documentation, access to the repository, a description of the production environment and an agreement that governs continuity. Verify that another team could take over the software without starting from scratch. This point should be negotiated before signing, not after.
When is a maintenance contract needed?
Almost always. Software needs security updates, adaptations to external systems and fixes. The contract must state what is included, how problems are reported and what response arrangements apply. Avoid generic wording and ask for examples of work already carried out.