Introduction

Imagine a business hires a software company to build an app. The contract says it will be delivered in four months. Six months pass, and the app still isn’t ready — or worse, it’s delivered full of bugs. Can the business sue? What can it claim? This is one of the most common disputes in the Indian IT industry today, and Indian contract law has clear answers. This article breaks down, in simple terms, what counts as a breach in a software contract, which laws apply, what past judgments say, and what steps you can actually take if this happens to you.

What Is a Breach of a Software Development Agreement?

A breach happens when either party fails to do what they promised in the contract. In software contracts, this usually means:

• The developer misses the delivery deadline
• The software doesn’t work as promised or fails testing
• The client stops making agreed payments
• Either side shares confidential project information without permission
• The developer hands over incomplete or unusable code

Under the Indian Contract Act, 1872, the party who suffers loss because of such a breach can claim compensation, and in some cases, cancel the contract entirely.

Types of Breach Common in Software Contracts

Delay in delivery — missing agreed milestones or the final deadline.

Defective software — bugs, missing features, or failing agreed acceptance tests.

Scope creep disputes — client keeps adding features without adjusting price or timeline, leading to conflict over what was “promised.”

Payment default — client refusing to pay after work is delivered.

Confidentiality/NDA violation — either party leaking source code, business data, or trade secrets.

IP ownership disputes — arguments over who owns the final code, especially in freelance or agency projects.

Legal Provisions That Apply

Several sections of the Indian Contract Act, 1872 come into play:

Section 37 — This is the starting point. It says every party to a contract must perform their own promise unless the law excuses them. If the developer promised delivery in four months, this section is what creates that legal duty.

Section 39 — If one party refuses to perform the contract, or makes it impossible to perform (for example, the developer abandons the project), the other party can treat the contract as ended and is no longer bound to continue their side.

Section 55 — This deals specifically with time limits. If the contract says the deadline is important (“time is of the essence”), missing it lets the aggrieved party cancel the contract. If time isn’t stated as critical, the aggrieved party can only claim compensation for the delay, not cancel the whole contract.

Section 73 — This is the main damages provision. It allows the aggrieved party to recover losses that either happened naturally because of the breach, or that both parties could reasonably have expected when they signed the contract. Losses that are too remote or unconnected to the breach cannot be claimed.

Section 74 — This applies when the contract already names a fixed amount as damages (a “liquidated damages clause”) — for example, ₹5,000 per day of delay. Courts don’t blindly enforce this number. They award what they consider reasonable compensation, capped at the amount mentioned in the contract.

Essential Clauses Every Software Contract Should Have

A big reason disputes drag on is that contracts are poorly drafted. A solid software development agreement should cover:

Milestone payments — tied to specific, measurable deliverables

Acceptance testing — a clear process and timeline for the client to test and approve the software

Warranties — what the developer guarantees about the software’s performance

Limitation of liability — a cap on how much either party can be made to pay if something goes wrong

Force majeure — protection for delays caused by genuinely unavoidable events (natural disasters, government restrictions, etc.)

Confidentiality/NDA — protecting business information and source code from being shared outside the project

IP ownership — spelling out clearly who owns the final code, especially important in outsourced or freelance work

Maintenance obligations — what support the developer must provide after delivery

Fixed-price vs. Agile/SaaS models — Agile projects (built in sprints) need different breach standards than fixed-price, fixed-scope projects, since “the deadline” is more fluid in Agile

Weak or missing clauses on these points are the number one reason software disputes end up in court instead of being resolved quickly.

Remedies Available for Breach

Damages — under Sections 73 and 74, as explained above

Termination of contract — under Section 39, if the other party’s conduct shows they won’t perform

Specific performance — asking the court to force the developer to complete the work — though Indian courts rarely order this for software contracts, since courts can’t easily supervise technical work

Arbitration — if the contract has an arbitration clause, the dispute must go through arbitration under the Arbitration and Conciliation Act, 1996, instead of a regular civil court

Landmark Judgments Every Reader Should Know

Hadley v. Baxendale (1854) — This old English case is still the foundation of Indian damages law. It laid down that a party can only claim damages for losses that either arise naturally from the breach, or that both parties knew were likely when they made the contract. Purely unexpected or remote losses cannot be claimed.

Fateh Chand v. Balkishan Das (1963) — The Supreme Court held that even where a contract names a fixed sum as compensation, the aggrieved party still generally needs to show that some real loss or “legal injury” occurred. Courts won’t automatically hand over the full named amount just because the contract says so.

ONGC v. Saw Pipes Ltd. (2003) — Here, the Court took a slightly different approach for commercial contracts where actual loss is hard to calculate. It held that if the damages clause is a genuine pre-estimate of loss (not an arbitrary penalty), the court can award that amount without demanding detailed proof of loss.

Kailash Nath Associates v. DDA (2015) — This case brought clarity by combining the earlier rulings: courts will only award the full stipulated amount if it’s a genuine pre-estimate of damages; otherwise, only “reasonable compensation” up to that amount will be given.

Together, these cases mean: having a damages clause in your software contract helps, but it’s not a blank cheque — courts will still look at whether the amount is fair and connected to real loss.

Step-by-Step Procedure to File a Suit

1. Send a legal notice to the defaulting party, describing the breach and demanding compensation within a set time.
2. Draft the plaint under Order VII Rule 1 of the Code of Civil Procedure, 1908, stating the facts, the breach, the loss suffered, and the relief sought.
3. Check for an arbitration clause in the contract — if present, the matter must go to arbitration instead of a civil suit.
4. File in the correct court based on where the contract was signed/performed and the value of the claim.
5. Pay court fees, usually calculated as a percentage of the amount claimed.
6. Proceed through summons, written statement, evidence, and hearing until judgment.

Practical Tips

• Keep every email, WhatsApp message, and project management log — these become your evidence of missed deadlines or defective work.
• Calculate your actual loss with real numbers (cost of a replacement vendor, lost business) rather than a vague claim — courts reduce unproven claims.
• Insist on a detailed, milestone-based contract before starting any project — most disputes trace back to a poorly written agreement.

Conclusion

Breach of a software development contract isn’t just a business inconvenience — it’s a legal issue with well-established remedies under Indian law. From Sections 37, 39, 55, 73, and 74 of the Indian Contract Act to landmark rulings like Fateh Chand and Kailash Nath Associates, Indian courts have built a fairly clear framework for such disputes. The best protection, though, is always a well-drafted contract — with clear milestones, IP terms, and a fair damages clause — signed before the first line of code is written.

Frequently Asked Questions

1. What is a software development agreement? It is a contract that governs the development, delivery, and ownership of software between a client and a developer or agency.
2. Can a client sue for delayed software delivery? Yes, if the delay amounts to a breach of contract and causes a provable loss to the client.
3. What remedies are available for breach of a software contract? Depending on the facts and the contract, remedies can include monetary damages, termination of the contract, and in limited cases, arbitration or specific performance.
4. Does Indian law recognize penalty clauses in software contracts? Yes, but courts examine such clauses under Section 74 of the Indian Contract Act and only award what they consider reasonable compensation.
5. Should software agreements include arbitration clauses? Yes — arbitration is usually faster and more suited to technical disputes than a regular civil court.