Disputes over software deliverables almost always trace back to one of three causes: ambiguous acceptance criteria, a mismatch between what was specified and what was built, or a subjective disagreement about whether something is "finished". The contract and the specification are the reference points for resolving any of these, which is why their clarity matters long before a disagreement surfaces.

Decision summary: Tie each disputed deliverable to the signed scope, acceptance evidence, notices, remedy and continuity plan.

A deliverable dispute is not the same as reporting a defect. A defect is something that fails against an agreed test or criterion. A dispute arises when the parties disagree about what the criterion was, whether it has been met, or whether a particular piece of work fell inside or outside the agreed scope. Recognising that distinction early shapes how you respond.

How to use this guidance safely

For “Handling Disputes Over Software Deliverables”, this is commercial guidance, not a substitute for advice on a particular contract. Definitions, schedules, governing law and the interaction between clauses can materially change the outcome. Record the operational requirement first, then have the wording reviewed for the actual transaction.

The contractual anchor

Your contract should set out the mechanism for handling disagreements before they happen. Typical provisions include a defined acceptance-testing period, a process for raising formal objections, and sometimes a technical escalation path such as an independent expert review. If your contract is silent on these points, you are negotiating resolution from a weaker position.

The specification, not verbal assurances or email threads, is the document that carries weight. If a feature was discussed in a meeting but never captured in the written acceptance criteria, resolving a dispute about it becomes significantly harder. Suppliers and buyers alike frequently assume that informal conversations carry the same weight as the signed requirements — they do not.

Scope drift as a dispute source

Many disputes that present themselves as quality complaints are actually scope disagreements. A buyer requests a change during development, the supplier accommodates it informally, and at sign-off the buyer expects further related work that the supplier considers out of scope. Without a formal change-control process, neither party has a clear record of what was agreed, varied, or declined.

Scenario: acceptance criteria were vague

A specification states that the system "should be fast" without defining response times, payload sizes, or test conditions. At sign-off, the buyer considers the performance unacceptable; the supplier argues it meets the stated requirement. Without measurable criteria, there is no objective way to resolve this. The practical response is to agree testable thresholds before development starts — for example, "page load under two seconds for a list of 500 records on a standard broadband connection" — and to insist on this level of specificity for every requirement that matters.

Scenario: the build matches the spec but not the expectation

The supplier delivers exactly what the specification describes, but the buyer realises it does not solve the underlying business problem. This is a discovery failure, not a delivery failure. The dispute here is uncomfortable because the supplier has technically performed, yet the outcome is unsatisfactory. Resolution usually involves negotiating a paid variation rather than demanding rework, unless you can demonstrate that the supplier should have identified the gap during discovery.

Scenario: partial delivery with contested sign-off

A supplier delivers most features but flags several as incomplete, requesting partial acceptance so they can invoice for completed work. The buyer refuses, wanting everything before paying. This situation is best handled by agreeing a phased acceptance mechanism in the contract — defining which groups of features can be signed off independently and what happens to payment if some groups remain incomplete.

Step-by-step approach to resolution

  • Separate defects from disagreements. List everything you consider wrong and categorise each item as a clear failure against a criterion, a scope question, or a subjective judgment.
  • Reference the written documents. For each item, note the exact clause, criterion, or requirement it relates to. If nothing in the contract or specification addresses it, acknowledge that upfront.
  • Put your position in writing. A formal email or letter that references specific contract sections is harder to dismiss than a phone call. It also creates a timeline if the dispute escalates.
  • Propose a resolution path. Stating what is wrong without suggesting how to resolve it prolongs the process. Where possible, offer options: rework, a variation, an independent assessment, or a partial sign-off with a documented list of outstanding items.
  • Agree a deadline for response. Open-ended disputes benefit the party that delays. Set a reasonable but firm timeframe for the supplier's formal reply.

When to involve a third party

If direct negotiation stalls, the contract may provide for mediation, expert determination, or arbitration. Expert determination is particularly suited to technical disputes because the appointed expert can make a binding decision on whether a deliverable meets its specification. Mediation is less formal and can preserve the working relationship, but the outcome is not binding unless both parties agree. Litigation is the last resort: it is slow, expensive, and rarely delivers a satisfactory technical outcome.

Common mistakes

  • Signing off too early to keep the project moving. Accepting a deliverable "subject to a few tweaks" creates ambiguity about what was actually accepted and what remains outstanding. If something is not right, either log it as a formal defect or refuse sign-off until it is resolved.
  • Relying on goodwill instead of documentation. A strong working relationship with your supplier is valuable, but it does not substitute for a clear contract and specification. When a dispute arises, goodwill evaporates quickly.
  • Accepting vague acceptance criteria at the start. The cheapest time to resolve ambiguity is before development begins. During a dispute, the cost of clarification is measured in time, money, and relationship damage.
  • Conflating poor project management with defective deliverables. Late delivery, poor communication, and missed updates are project-management issues. They may justify a contractual remedy, but they are not the same as the software failing to meet its specification.
  • Withholding payment as a first response. Unilateral withholding of payment can itself be a breach of contract. Check the payment terms carefully before using this as leverage.

Limitations of contracts and specifications

No contract eliminates all dispute risk. Specifications cannot anticipate every edge case, and language is inherently open to interpretation. A well-drafted contract reduces the area of disagreement but does not remove it entirely. The practical limit is this: if the parties are fundamentally misaligned on what they are building, no amount of contractual precision will prevent a dispute — it will simply change its nature from a scope disagreement to a semantic argument about wording.

Contracts also cannot compensate for inadequate discovery. If the business need was never properly understood, the specification will reflect that gap, and the resulting system will be technically compliant but operationally useless. Addressing discovery failures after delivery is far more expensive than catching them before the first line of code is written.

Key checks before a dispute arises

  • Are your acceptance criteria testable? Every criterion should be verifiable by someone who was not involved in writing it. If you cannot define a test that would pass or fail the criterion, it is not ready.
  • Does the contract define the dispute-resolution process? Check for provisions on expert determination, mediation, or arbitration. If none exist, raise this before signing — not after a disagreement surfaces.
  • Is there a change-control process? Verify that every variation, however small, is documented with its impact on scope, cost, and timeline. Informal changes are the most common source of scope disputes.
  • Have you kept a contemporaneous record? Meeting notes, decision logs, and email threads that reference specific requirements are valuable evidence. A dispute decided on documentation usually favours the party that wrote things down at the time.
  • Have you distinguished between "must-have" and "nice-to-have"? If everything is a priority, nothing is. Clear prioritisation helps both sides understand what constitutes a blocking issue at sign-off and what can be deferred.

Disputes over software deliverables are costly in time, money, and trust. The majority are preventable through precise acceptance criteria, a clear change-control process, and a contract that sets out what happens when the parties disagree. When a dispute does arise, the fastest path to resolution starts with separating genuine defects from scope disagreements, referencing the written documents, and proposing a concrete way forward rather than simply rejecting the work.

Contract points to settle before signature

  • Identify which signed document controls if schedules, proposals or emails conflict.
  • Obtain current legal advice for the actual parties and transaction before relying on contractual wording.
  • Make the contract, schedules, statement of work and change-control process consistent with one another.
  • Distinguish ownership, licence rights, practical access and third-party restrictions.

Primary guidance checked for this edition

Sources for “Handling Disputes Over Software Deliverables” were checked on 22 July 2026. Recheck the applicable rules, product documentation and contractual terms before implementation because these can change after the review date.