Software liability is the legal responsibility that developers, sellers, and distributors carry when defective code causes harm, and whether an injured user can actually recover depends less on the severity of the harm than on three gatekeepers: how the transaction is classified, what the license agreement says, and whether the loss was financial or physical. Those three filters decide most cases long before anyone argues about the code itself.
The Three Legal Theories Behind a Claim
Nearly every software liability case runs on one of three tracks: negligence, breach of warranty, or strict products liability. The track you’re on determines what you have to prove and what the developer can argue in response.
Negligence
A negligence claim asks whether the developer exercised reasonable care when designing, coding, and testing the software. You have to show the developer owed you a duty of care, fell below the standard a competent professional would meet, and that the shortfall caused your harm. If a development team ships a release without patching a vulnerability the broader security community flagged weeks earlier, that gap between what they did and what a reasonable team would have done becomes the centerpiece of the claim.
Negligence is flexible enough to cover sloppy input validation, skipped regression testing, or a rushed update. The hard part is proof. Source code, commit histories, and internal communications all become evidence, and building a timeline of what the developer knew and when they knew it is expensive.
Breach of Warranty
Warranty claims focus on broken promises rather than careless conduct. An express warranty exists when the seller makes specific representations about what the software will do, whether in marketing materials, documentation, or a contract. If the product manual says the software can handle 10,000 concurrent users and it crashes at 500, that is a straightforward breach of express warranty.
Implied warranties arise automatically under commercial law without anyone writing them into the deal. The implied warranty of merchantability guarantees the software is fit for its ordinary purpose. The implied warranty of fitness for a particular purpose kicks in when the seller knows the buyer needs the software for a specific job and the buyer relies on the seller’s expertise. These protections only apply when a court treats the transaction as a sale of goods, which is a separate fight explained below.
Strict Products Liability
Strict liability holds a manufacturer responsible for a defective product regardless of how careful it was. You don’t have to prove negligence, only that the product was defective and the defect caused harm. The doctrine developed in the 1960s to deal with the reality that consumers of complex products often cannot pinpoint where in the manufacturing process something went wrong.
Whether software qualifies as a “product” for strict liability purposes is one of the most contested questions in the field. Courts tend to look at whether the code was mass-marketed as a standardized package or custom-built for a particular client. Off-the-shelf software sold to thousands of users looks like a traditional product. Custom development, where the programmer’s knowledge and skill are the real deliverable, looks like a service. Strict liability does not apply to services.
Is the Software a Good or a Service?
Article 2 of the Uniform Commercial Code governs the sale of goods, and the protections it offers buyers are substantial. The threshold question in software disputes is whether the transaction counts as a sale of goods at all. If it does, the buyer gets implied warranties of merchantability and fitness automatically. If the court classifies the transaction as a service, those protections vanish and the buyer is limited to whatever the contract specifically promises.
Most courts resolve the question using the predominant purpose test, which looks at the whole transaction to decide whether its primary objective was delivering a tangible product or providing professional expertise. A shrink-wrapped office suite bought off a shelf lands in the goods column. A six-month engagement where developers build custom analytics tools from scratch tilts heavily toward services. The gray area in between is enormous, and that is where litigation gets expensive and outcomes get unpredictable.
Cloud-based software complicates the picture further. When a business pays a monthly fee to access an application hosted on someone else’s servers, it arguably never buys anything at all. There is no transfer of a copy, no installation media, and the provider can change the software at any time. Courts evaluating SaaS contracts have increasingly focused on whether the transaction centers on data processing, storage, and reporting, all of which point toward a service classification that removes UCC protections entirely. For the buyer, that means the license agreement is the only source of legal protection, and if that agreement disclaims warranties and caps liability at the subscription fee, a catastrophic failure may produce no meaningful remedy.
What the EULA You Clicked Through Actually Does
End User License Agreements are the first line of defense for software companies, and they are remarkably effective. These contracts appear during installation or account creation and require acceptance before you can proceed. Courts routinely enforce clickwrap agreements when the terms are reasonably accessible and the user affirmatively assented.
Three provisions do most of the work. An “as-is” clause declares that the software is provided without any warranties. A warranty disclaimer explicitly cancels the implied warranties commercial law would otherwise supply. A limitation of liability clause caps the developer’s maximum financial exposure, typically at the amount paid for the license or subscription. A business that paid $200 for a software license and then suffered $2 million in losses from a defect may find its recovery capped at $200.
Courts generally enforce these provisions when the language is clear and conspicuous, the user had a meaningful chance to review the terms, and the clause does not violate public policy. The public policy exception is narrow but real: a court is more likely to strike down a liability cap on software controlling a medical device or safety-critical system than one running a photo editor. In practice, most commercial software disputes end with the user bound by the agreement they clicked through without reading.
The Economic Loss Rule and Why Most Financial-Harm Cases Die
Even when a EULA does not block the claim, the economic loss rule often does. The doctrine prevents plaintiffs from using tort law to recover purely financial harm. If a software defect costs you money but does not injure anyone or damage physical property, the rule pushes your claim into contract law, where recovery is limited to whatever the agreement provides.
Consider a retailer whose point-of-sale system crashes during the holiday season, costing three days of revenue. The harm is entirely financial. Under the economic loss rule, the retailer cannot sue the developer for negligence. The retailer must look to the license agreement, and if that agreement disclaims consequential damages, the retailer may recover nothing at all. This is where most small-business software claims die.
The rule has a clear boundary. When defective software causes physical injury or damages other property beyond the software itself, tort claims become available. If a flaw in industrial control software causes a machine to overheat and start a fire, the business can pursue negligence or strict liability claims for the fire damage and any injuries. Physical harm opens the door that pure economic loss keeps shut.
Some jurisdictions recognize a narrow independent-duty exception. If a statute imposes obligations on the developer beyond whatever the parties negotiated, breaching those obligations can support a tort claim even for economic losses. A data security statute requiring specific safeguards is one example. Courts remain split on how far the exception reaches, and the case law varies significantly by jurisdiction.
What Counts as a Software Defect
Claims typically target one of three defect categories borrowed from traditional products liability law. The category matters because it determines what evidence you need and what defenses the developer can raise.
- Design defects: the fundamental architecture or logic of the software is flawed. Every copy contains the problem because the mistake was made during planning, not implementation. A database application that stores passwords in plaintext by design has a design defect.
- Implementation defects: the plan was sound but the execution failed. A coding error, a race condition, or a bug introduced during a specific update falls here. These defects may affect only certain versions or configurations, which makes them harder to detect and harder to prove.
- Failure to warn: the developer knew or should have known about a risk and did not alert users. If software is incompatible with a widely used security tool and the developer does not disclose that, users breached because of the incompatibility may have a failure-to-warn claim. Actual knowledge is not required; the standard is whether a reasonable developer would have discovered and disclosed it.
Not every bug is legally actionable. A minor glitch that causes an occasional cosmetic error is different from a defect that corrupts data or creates a security vulnerability. The severity of the resulting harm and the foreseeability of the risk are what separate an annoyance from a viable claim.
You Can’t Blame the Third-Party Library
Modern software is rarely built from scratch. Industry estimates suggest roughly 80 percent of a typical enterprise application consists of third-party code, primarily open-source libraries. When a vulnerability in one of those components leads to a breach or system failure, the general rule in both U.S. and international regulation is that the company shipping the final product is responsible for the security of every component in it.
Executive Order 14028, signed in 2021, pushed federal agencies and their suppliers toward stricter software supply chain practices, including Software Bills of Materials that catalog every component in a product. A developer who integrates a third-party library has a duty to monitor it for known vulnerabilities and patch or replace it when problems emerge. Telling a court that the flaw was in someone else’s code is not a defense if you chose to include that code and failed to keep it updated.
Government Enforcement as a Separate Track
Beyond private lawsuits, software companies face enforcement from federal agencies.
The Federal Trade Commission uses Section 5 of the FTC Act to pursue companies whose software security practices constitute unfair or deceptive acts. The agency has brought actions against organizations for failing to live up to privacy promises, failing to maintain reasonable security for sensitive consumer information, and causing substantial consumer injury through security failures.1Federal Trade Commission. Privacy and Security Enforcement The FTC does not need to wait for a data breach; if a company’s security practices are unreasonable given the sensitivity of its data, the agency can intervene. FTC actions typically produce consent orders mandating specific security improvements, independent audits, and reporting requirements for up to 20 years. For a software company, that can be more damaging than a private lawsuit because it imposes ongoing compliance obligations and makes future violations far more expensive.
The Internet of Things Cybersecurity Improvement Act directed NIST to publish security standards for IoT devices connected to government systems, covering vulnerability management, secure development, identity management, patching, and configuration management. Since December 2022, federal agencies cannot enter or renew contracts for IoT devices that fail to comply. The law applies directly only to government procurement, but the NIST standards are rapidly becoming the benchmark courts and regulators use to evaluate whether any IoT developer exercised reasonable care.
AI Systems and the Open Questions
Artificial intelligence creates liability questions existing frameworks were not designed to answer. When a traditional program fails, you can usually trace the defect to a specific line of code or design decision. When an AI system produces a harmful output, the failure may be embedded in training data, model architecture, or emergent behavior no individual developer intended or foresaw.
As of 2026, the United States has no comprehensive federal AI liability law. Federal regulation operates through a patchwork of executive actions, existing statutes applied to AI use cases, and agency enforcement. The FTC applies Section 5 to deceptive AI practices, particularly misleading claims about what an AI system can do.1Federal Trade Commission. Privacy and Security Enforcement The broader question of who answers when an AI system causes harm through autonomous decision-making remains largely unresolved in American courts.
The goods-versus-services classification matters here too. If a generative AI tool is treated as a product, strict liability could reach harmful outputs. If it is treated as a service, liability would likely require proving the provider failed to take reasonable technical and governance measures given the current state of the technology. Early international case law has leaned toward the service classification, evaluating providers on whether they adopted reasonable safeguards rather than guaranteeing accuracy.
When Enhanced Damages Are on the Table
Most software liability claims result in compensatory damages, subject to whatever contractual caps apply. Punitive damages are available only in narrow circumstances. You typically must show gross negligence, meaning conduct that substantially deviates from what a reasonably careful developer would do, or willful disregard for user safety. Shipping a product with a known critical vulnerability because fixing it would delay a revenue target is the kind of conduct that can support punitive damages. A garden-variety coding mistake, even one with serious consequences, usually will not.
State consumer protection statutes offer another path to enhanced recovery. Many states have unfair and deceptive practices laws that let successful plaintiffs recover attorney fees and, in some cases, statutory multipliers on their damages. These statutes can shift the economics of litigation enough to make small claims viable that would otherwise cost more to bring than they are worth. The specific remedies and standards vary by state.
The Practical Barriers That Decide Most Cases
Legal theory is one thing; actually winning is another. Statutes of limitations impose hard deadlines. Depending on the jurisdiction and the type of claim, you may have as little as two years from discovering the defect to file. Contract claims sometimes allow longer, but the clock starts when the breach occurs, not when you notice the damage. Missing the deadline forfeits the claim regardless of its merits.
Discovery is expensive and technically complex. You often need access to source code, development documentation, testing records, and internal communications to prove what the developer knew and when. Developers routinely resist producing source code on trade secret grounds, and courts have to balance that against your need for evidence. Expert witnesses who can translate code-level failures into language a jury understands are essential and costly.
For individual consumers and small businesses, the combination of contractual damage caps, the economic loss rule, and high litigation costs often makes pursuing a claim impractical. Small claims courts in most states handle disputes somewhere between $3,000 and $20,000, which may cover a refund but not the consequential losses that actually hurt. Class actions can aggregate many small claims into a viable lawsuit, but they add procedural complexity and can take years to resolve.