desarrollo · 4 min read
Custom software contracts: the clauses you can't leave out
Scope, payment milestones, acceptance testing, SLA and exit terms: the clauses any custom software development contract needs before you sign.
“What happens if the project runs late, or if we stop agreeing with the provider halfway through?” is the question that decides whether a custom software contract is worth anything the day things don’t go as planned. At Evicron, an AI and custom software studio based in Barcelona founded in 2019 with over 200 projects delivered across 12 sectors, we go through this document with every client before signing, because most disputes with a provider don’t come from bad faith — they come from a clause nobody wrote.
Scope belongs in the contract, not just the quote
A generic description like “build a web application” doesn’t work as contractual scope: it’s not enough to tell, when it matters, whether something is in or out of the project (dig.es). The contract should set out functional specifications, technical and performance requirements, the external integrations involved and the deployment environment, usually as an annex. That’s the foundation everything else rests on: without a written scope, there’s no objective way to decide whether a change the client asks for is free or billed separately.
Payments should be tied to milestones, not the delivery date
Paying everything at the end leaves both the provider and the client with no real lever if something goes wrong halfway through. A common pattern in the industry splits payment into four parts: 30% upfront, 30% at the midpoint of development, 30% on delivery, and a final 10% after a 30-to-60-day warranty period with no issues (developargentina.com). It’s not a fixed rule — every project negotiates its own split — but the underlying principle is universal: each payment milestone needs an explicit acceptance criterion, not just a date on a calendar.
What happens when a change is requested mid-project
Without a change-control procedure, scope quietly expands without anyone formally deciding it, and that’s the most common reason a project ends up over budget or late with neither side quite sure why. The process that works is simple: the client requests the change in writing, the provider assesses its impact on time and cost, presents a proposal, the client approves or rejects it, and it’s only executed once that written approval exists. It looks like red tape; in practice, it’s the only thing stopping an informal email request from turning into an argument about who pays for the extra work.
Acceptance testing: what counts as a defect, and how fast it gets fixed
The contract should set a deadline for acceptance testing, a procedure for reporting defects, and an incident classification — critical, major, minor — with a maximum fix time for each, and it should clearly separate a real defect from an improvement the client hadn’t actually asked for before (dig.es). That distinction avoids the most frequent conflict in the final stage of a project: a client treating something as a “bug” when it’s really a new feature outside the original scope.
SLA and maintenance: what happens after delivery
If the contract includes hosting or maintenance, it’s worth setting an SLA with response and resolution times by severity. A reference table common in the industry — which every contract should adapt to how critical the system actually is — sets out four levels: a full outage gets a one-hour response and four-hour resolution; a core function affected, four-hour response and 24-hour resolution; a secondary function, eight-hour response and 72-hour resolution; and a minor or cosmetic bug, 24-hour response and five business days to resolve (developargentina.com). If the software handles customer or employee data, the maintenance contract also overlaps with the GDPR — how fast the provider must notify a breach, who can access production — which we cover in detail in our guide on what your provider must guarantee on security.
The exit clause: what happens if the relationship ends
A serious contract defines at least four end-of-relationship scenarios in writing: mutual agreement, breach by either party, termination without cause — typically with 30 days’ notice and payment for work already done — and, in any case, what gets handed over when it ends: the code, the documentation, the access credentials, and a transition period to migrate without the service breaking (developargentina.com). This clause is the other side of a question we already covered in detail in our guide on who owns the code in your custom software: it doesn’t help much that the code is legally yours if the contract never says how fast, and with what support, you actually get it.
How we handle this at Evicron
We work with a 4-phase process and weekly sprints, with a browsable demo already in the second week, so scope and payment milestones are clear from the first quote rather than negotiated after the fact. The contract reflects the same criteria described here — scope as an annex, payment by milestone, acceptance testing with deadlines, an SLA if maintenance is included, and an exit clause with no fine print — because those are exactly the points that, when missing, end up as an expensive argument.
If you’re about to sign a custom software contract and want us to go through what’s missing with you — or you’re still collecting quotes and aren’t sure what to ask — you can get in touch and we’ll go through it in a first, no-cost conversation.