One of the most expensive misunderstandings in technology insurance is assuming that a general liability policy will cover a software dispute. It will not. These are two fundamentally different policies built for two fundamentally different kinds of risk — and a working Python developer or data consultancy almost always needs both. This post explains exactly what each one covers, why a bug is not a general liability claim, and the claims-made mechanics that make tech E&O behave very differently from GL.
What general liability actually covers
General liability (GL) is the broad, foundational policy for physical-world accidents and premises risk:
- A client or visitor is injured at your office.
- You damage a client's property during an on-site engagement.
- A slip-and-fall happens at your co-working space.
- Personal and advertising injury — libel or slander in your marketing.
GL is the certificate a landlord, co-working operator, or client procurement team usually asks to see first, which is why even fully remote teams often carry it. It is inexpensive and frequently bundled into a Business Owner's Policy. But notice what is on that list: bodily injury and property damage. Physical things. Nothing about your code.
The critical exclusion: professional services
Here is the part developers miss. General liability policies explicitly exclude the professional and technology services that are your actual business. The work you are paid to do — writing software, architecting data pipelines, deploying models — is carved out of GL by design.
So when a client sues because your migration dropped a production table, your payment integration double-charged customers, or your project shipped late and cost them revenue, GL does not respond. That is not a gap or an oversight; it is how the policy is structured. The financial loss caused by your work product is simply not what GL was built to insure.
Why a bug is not a GL claim
A bug causes economic loss — lost revenue, remediation costs, customer refunds — flowing from your professional work. General liability covers bodily injury and physical property damage. The two don't overlap. When a client says "your software broke our checkout and we lost $200,000 over the weekend," there is no bodily injury and no damaged physical property. There is a defect in a deliverable. That claim belongs to a different policy entirely.
What tech E&O covers
Technology Errors & Omissions (tech E&O) is the policy built for exactly that claim. It combines professional liability — your software, services, or advice caused a client a financial loss (bugs, failed deployments, missed deadlines, failure to deliver) — with cyber liability — a breach exposed data — into one form for technology firms.
Tech E&O responds to:
- Defects, bugs, and failed deployments causing client financial loss.
- Failure-to-deliver, failure-to-perform, and professional negligence.
- Breach of contract and unmet SLA or acceptance-criteria allegations.
- Data breach and privacy liability (on most combined forms).
It pays defense costs and damages that routinely exceed the project fee. This is the policy enterprise clients name in their Master Services Agreements, usually at $1M–$5M limits, before they will sign.
Occurrence vs. claims-made — the mechanic that trips people up
GL and tech E&O are not just different in scope; they are triggered differently.
GL is written on an occurrence basis. It responds to incidents that *happen* during the policy term, no matter when the claim is filed — even years later.
Tech E&O is written claims-made. The policy must be active both when the work was done *and* when the claim is filed. Software claims often surface long after delivery — a latent bug or a breach discovered months later — so carriers use the claims-made structure to price that long, uncertain tail.
Three terms follow from this:
- Retroactive date — the earliest work date the policy will cover. Work done before it is not covered, so keep this date as early as possible and never let a gap reset it.
- Prior acts — coverage for work done before the current policy began, back to the retroactive date. Vital when switching carriers so past projects stay covered.
- Tail coverage (Extended Reporting Period) — lets you report claims after the policy ends. Essential when you switch insurers or wind down the business, so a late-surfacing claim isn't orphaned.
With occurrence-based GL, none of this applies; the policy that was active when the incident occurred responds. With claims-made tech E&O, these mechanics are everything.
Why you need both
A Python firm faces both risk categories at once. A visitor could trip in your office (GL) and a client could sue over a failed deployment (tech E&O) in the same year. GL satisfies the landlord and the procurement checklist; tech E&O backstops the most expensive realistic claim you face — the one arising from the code itself. Carrying one and assuming it covers the other is how firms discover, mid-lawsuit, that they were never protected at all.
The takeaway
General liability is for the physical world and excludes your professional work. Tech E&O is for the financial harm your software and services can cause, and it is written claims-made with a retroactive date and tail coverage. They are complementary, not interchangeable. Most Python developers and consultancies should carry both.