Abstract
When a company commissions the development of custom software from an external provider, it rightfully expects a working, reliable product delivered on time. However, delays, bugs, and issues that disrupt business operations are not uncommon. In these cases, the inevitable question arises: is the software house liable?
Obligation of result: what happens if the software doesn’t work as expected?
The responsibility of a software house goes beyond simply “doing its best”. When custom software is developed—whether it’s an ERP, CRM, e-commerce platform, or management system—the provider undertakes a true obligation of result: the software must perform as agreed.
If the software is delivered but fails to perform the required functions, excuses like “we’re still working on it” or “it needs time to stabilize” are not sufficient. This constitutes a clear breach of contract.
This principle was confirmed by the Court of Milan, judgment no. 5752/2017. In that case, a software house delivered a management system on time, but it was unusable due to major technical flaws. The Court ruled that merely meeting deadlines wasn’t enough—what mattered was that the product functioned for its intended use. The judgment led to the termination of the contract, refund of payments, and compensation for damages.
Even delivery delays can carry significant legal consequences. If a software house misses deadlines—especially for business-critical projects—it can result in lost revenue, missed opportunities, and operational issues. No penalty clause is needed: Article 1218 of the Italian Civil Code holds the debtor (the software house) accountable for non-performance unless it proves the delay was beyond its control.
One of the most contentious issues is the failure to deliver the source code. Many businesses discover too late that, despite paying in full, they cannot modify or migrate the software because they don’t own its “heart”. Holding the source code as a contractual leverage is illegitimate unless explicitly stated in the contract, according to prevailing case law (see Breach of contract in software development: how to recover the source code? – Canella Camaiora).
Crashes, bugs, losses, and the software house’s liability for damages
Receiving incomplete or malfunctioning software is already problematic. But when it causes tangible, documentable financial damages, the software house’s liability is almost certain. This goes beyond a simple breach and becomes an issue of damages suffered by the client.
Examples include: a management system that loses financial data, a CRM that sends incorrect messages to customers, or an e-commerce platform crashing during a promotional campaign.
The most common causes of liability in software development are:
- design errors,
- lack of testing, especially for critical modules,
- security vulnerabilities,
- absence of recovery measures.
A useful tool to mitigate these risks is the so-called Agile development contract.
Of course, the client must prove the breach, the damage, and the causal link between the two.
Liability may also extend to indirect damages, such as lost commercial opportunities or operational disruptions, as long as they are clearly attributable to the software’s defect.
When the client is to blame
It’s important to recognize that the software house is not always to blame. While developers must respect timelines, specifications, and agreed functionalities, the client also plays a crucial role in the project’s success.
Issues often arise when clients repeatedly change requirements without updating the documentation or signing a revised technical analysis. Sometimes, modifications are requested verbally or over unrecorded phone calls. These scenarios can blur the contractual scope and lead to disputes.
Another common issue is the client skipping functional tests—often to speed up the launch. In doing so, they forgo the opportunity to identify issues before final delivery.
This can result in concurrent liability (under Article 1227 of the Italian Civil Code), reducing the software house’s responsibility proportionally to the client’s negligence. If the client’s actions contributed to the damage, compensation may be reduced or even excluded.
Clearly defining boundaries prevents disputes
In custom software development, responsibility is a nuanced concept. Software houses must deliver a functioning product, aligned with specifications and deadlines. At the same time, clients must actively collaborate and carefully document every project step.
Case law is clear: if the software doesn’t work, is delivered late, or lacks key components like the source code, the software house can be held liable—with significant financial consequences. However, careless client behavior can reduce or nullify this liability.
Therefore, it is essential to establish a transparent, precise, and verifiable contractual relationship from the outset. This is the only way to protect your technological investment and avoid disputes that may not only be costly but also disruptive to business operations. The key is simple: set clear, effective contractual rules.
© Canella Camaiora S.t.A. S.r.l. - All rights reserved.
Publication date: 19 June 2025
Textual reproduction of the article is permitted, even for commercial purposes, within the limit of 15% of its entirety, provided that the source is clearly indicated. In the case of online reproduction, a link to the original article must be included. Unauthorised reproduction or paraphrasing without indication of source will be prosecuted.
Margherita Manca
Avvocato presso lo Studio Legale Canella Camaiora, iscritta all’Ordine degli Avvocati di Milano, si occupa di diritto industriale.