What a Post-Launch Warranty Clause Actually Covers
Published by CodeNicely, the product studio founded by Meghal Agrawal and Ujjwal Agrawal in 2017For: A UK seed-stage SaaS founder who has just signed off on go-live and is about to countersign a contract whose warranty section they have not read closely — because they assumed 'warranty' meant the vendor would fix anything that broke
In this guide
- What the warranty clause is actually for
- The four things the clause almost certainly limits
- The scope-vs-defect argument you will lose
- The wording that protects you vs the wording that quietly does not
- What a reasonable post-launch support model looks like
- The five questions to put to your vendor before you sign
- How CodeNicely can help
- Frequently Asked Questions
A standard post-launch warranty in a software development contract covers one narrow thing: defects where the delivered software demonstrably fails to match the acceptance criteria you signed off at go-live. It does not cover performance under real-world load, third-party API failures, AI model drift, or anything a reasonable person would call "a bug we found after launch." If your contract has a 30-day warranty — the UK market norm — and you spend those 30 days onboarding customers rather than regression-testing, you will almost certainly emerge from the warranty window with a backlog of issues your dev partner is contractually entitled to bill as new work.
This post walks through what the warranty clause in a custom software or MVP build contract actually says, where the gaps sit, and the specific wording to push back on before you countersign. It is written for founders, not lawyers. It is not legal advice. Have a solicitor review your final document — the cost of one hour of their time is trivial next to the cost of the first production bug that falls outside scope.
What the warranty clause is actually for
The post-launch warranty exists for one purpose: to give the vendor a time-boxed obligation to fix defects in what they built, on the condition that those defects are provable against a document both sides agreed to. That document is your acceptance criteria. Everything in the warranty clause — the duration, the exclusions, the remedies — exists in reference to it.
This matters because UK contract law for custom software leans heavily on express terms. The 2024 Commercial Court decision in Kompaktwerk v LivePerson confirmed that SaaS is not a "sale of goods" under English law, which means the implied statutory protections buyers rely on for physical products do not automatically apply (OEC Law). What your vendor must fix is what the contract says they must fix. Nothing more.
So the question is not "is there a warranty?" The question is: what does the warranty explicitly cover, how long does it last, when does the clock start, and what is excluded?
The four things the clause almost certainly limits
1. Duration — and it is shorter than you think
Industry norms for custom software warranties sit at 30 to 90 days from formal acceptance, with 30 days recognised as standard for projects that have a formal acceptance phase (developer.law / Story LLP). A 30-day window sounds reasonable until you map it against what a seed-stage SaaS actually does in the first month after launch: onboard design partners, chase integrations, fix UX, probably pitch investors. You are not stress-testing the system. Real defects surface in weeks four through twelve. The warranty expires in week four.

What to push for: 90 days minimum. If the vendor resists, ask for a tiered structure — full warranty for 30 days, then a reduced-scope warranty (critical bugs only) for a further 60.
2. The "deemed acceptance" trap
UK development contracts routinely include a deemed acceptance clause. If you do not formally reject the deliverable within a testing window — typically 5 to 10 working days — or if you begin using the software in production, acceptance is legally recorded as complete and the warranty clock starts (fixology.co.uk). Most founders miss this entirely. They push to go live, start onboarding users, and by the time they realise anything is wrong the clock has been ticking for a fortnight.
What to push for: A testing window of at least 10 working days, with the clock starting only once a named test environment and sample data are available. Make the acceptance criteria a signed document, not an email thread. If you miss the formal rejection window because of a founder emergency, a well-drafted contract will let you extend it once.
3. Exclusions you will not notice until they bite
The standard warranty clause covers "behaviour that does not match the agreed scope, meaning technical defects" — and explicitly excludes failures caused by third-party services or changes made by the customer (shahnur.software). In plain English, if Stripe's API changes and your payment flow breaks, that is not a warranty issue. If your AWS bill spikes because the system scales badly under load the vendor never tested against, that is not a warranty issue. If a developer on your team pushes a config change and something breaks, that is not a warranty issue.
The list of "not a warranty issue" is long. Most of it is reasonable. But you need to see the list in writing and know which exclusions you can negotiate.
4. The AI drift gap
If any part of your product uses an ML model or an LLM-based feature, the warranty clause almost certainly does not cover model drift. A peer-reviewed study in Nature Scientific Reports tested 128 model–dataset combinations and found temporal performance degradation in 91% of them (Lumenova AI citing Nature). McKinsey found 40% of companies deploying AI models saw noticeable degradation within the first year, and IBM has noted accuracy can decline within days when production data diverges from training data (GAICC.org citing McKinsey and IBM).
Here is the structural problem: the warranty is written against acceptance criteria measured at a single point in time. The model passed those tests on launch day. Three weeks later it is producing worse outputs because the live data distribution has shifted. Nothing is technically defective. The vendor delivered what was tested. Your product is getting worse. This is a billable engagement, not a warranty fix.
What to push for: A separate "model performance" clause for any AI feature, with a defined performance metric (accuracy, precision, F1, or a task-specific measure), a monitoring window, and an agreed remediation path if the metric falls below threshold. If the vendor cannot articulate how they will monitor drift, that is a signal about how the AI component was actually built.
The scope-vs-defect argument you will lose
The single most common UK startup–developer dispute is the one where "a developer treats a feature as extra work while the startup sees it as part of the original build" (Sprintlaw UK). The warranty clause is where this fight happens. The developer points to the acceptance criteria and says: the software does what this document says it does. You point to the user complaint and say: but it does not work. Both of you are correct, and the acceptance criteria decide who pays.
This is why the acceptance criteria matter more than the warranty clause itself. A tight warranty against loose acceptance criteria protects the vendor. A reasonable warranty against detailed, measurable acceptance criteria protects you.
Good acceptance criteria are specific. "The search feature returns results in under 500ms for a database of up to 100,000 records" is enforceable. "The search feature works well" is not. If your contract's acceptance criteria read like marketing copy, rewrite them before you sign.
The wording that protects you vs the wording that quietly does not

| Topic | Wording that protects you | Wording that quietly does not |
|---|---|---|
| Duration | "90 days from the date the Customer issues a signed Acceptance Certificate" | "30 days from go-live" or "from first production use" |
| Defect definition | "Any failure of the Software to conform to the Specification, including performance against the load and concurrency thresholds set out in Schedule X" | "Material defects in the Software" with no definition of material |
| Acceptance | "Acceptance occurs on written sign-off following a 10-working-day UAT period in a vendor-provided staging environment" | "Acceptance is deemed to occur on first live use or 5 days after delivery, whichever is earlier" |
| Remedy | "Vendor shall remedy defects at no additional cost within [defined response times by severity]" | "Vendor shall use reasonable endeavours to address defects" |
| Third-party services | "Vendor remains responsible for integration logic; Customer responsible for third-party service availability" | "Vendor not liable for any failure involving third-party services" (too broad — covers integration bugs too) |
| AI features | Separate Schedule defining performance metric, monitoring cadence, and drift remediation path | Silence. If AI is in scope and the contract does not mention drift, the gap is yours. |
What a reasonable post-launch support model looks like
The warranty is not the only lever. Most serious dev partners offer a post-launch support agreement that sits alongside the warranty — a paid retainer for defined hours per month, with SLAs, covering everything the warranty does not. This is where ongoing AI monitoring, third-party integration maintenance, and capacity scaling live.
The structure matters more than the price. What drives the cost of post-launch support:
- Response time SLAs. A one-hour response for P1 incidents costs more than a next-business-day response. Decide what your users will actually tolerate.
- Coverage hours. UK business hours is cheapest. 24/7 is a different pricing tier and requires an on-call rotation.
- Scope of included work. Bug fixes only, versus bug fixes plus minor enhancements, versus a full ongoing product team.
- AI monitoring. If the vendor is monitoring drift, running retraining, or managing an inference pipeline, that is a different cost structure from static software maintenance.
- Infrastructure responsibility. Who pays the cloud bill? Who responds when it spikes? These need to be explicit.
As an illustrative example — not a quote — a two-integration SaaS MVP with a single AI feature, business-hours support, and a 4-hour P1 response SLA sits in a very different pricing band from a consumer product with 24/7 coverage and active model monitoring. The ratio between those two can be 3–5x. Any specific figure depends on your stack, user base, and what you need the vendor to actually do at 2am on a Sunday. The two or three specifics that would turn the range into a real quote: your availability requirements, the number of live integrations and AI components, and whether the vendor is responsible for infrastructure or only application code. A conversation with your delivery partner is the only way to size it properly.
One more thing worth internalising: IBM Systems Sciences Institute data, corroborated by NIST, show that fixing a defect found in production costs 60–100x more than fixing the same defect at design stage (ContextQA citing IBM SSI and NIST). Every bug that falls outside the warranty is a production bug paid at production prices. The cost of a longer warranty window, or a well-scoped support retainer, is trivial by comparison.
The five questions to put to your vendor before you sign
- When exactly does the warranty clock start, and what happens if we are not ready to formally accept on the planned date?
- Walk me through a worked example: a user reports a bug three weeks after go-live. How do you decide whether it is a warranty fix or new work?
- Our product has an AI component. How is model performance measured at acceptance, and what happens if it degrades in production?
- If a third-party API we integrate with changes its contract and our feature breaks, is the fix warranty work or billable?
- What does your post-launch support agreement cover that the warranty does not, and what would you recommend for a product at our stage?
A vendor who answers these clearly, with examples, is worth trusting. A vendor who gives you vague reassurance is telling you how the first post-launch dispute will go.
How CodeNicely can help
We build MVPs and AI-first products for seed and Series A startups, and we have been on both sides of this conversation. On GimBooks, a YC-backed fintech, the post-launch model was the difference between the product surviving its first scaling event and stalling — we structured a warranty window tied to measurable acceptance criteria (transaction accuracy, reconciliation thresholds, response times under concurrent load) and a support retainer that covered the integration and infrastructure work the warranty intentionally did not. When the product hit real-world load, the arguments about scope did not happen, because the paperwork had already answered them.
For founders about to sign a build contract, the useful conversation is usually not about the warranty wording itself — it is about whether the acceptance criteria are specific enough to make the warranty meaningful, and whether the AI components (if any) have a monitored performance baseline. If you want a second pair of eyes on either, our AI Studio team reviews these for founders regularly. We do not do legal review — that is your solicitor's job — but we can tell you where the technical gaps sit before they become invoiced.
Frequently Asked Questions
How long should a post-launch software warranty last for a UK SaaS startup?
Market norm for custom software is 30 to 90 days from formal acceptance, with 30 days being standard (developer.law). For a seed-stage SaaS, 30 days is almost always too short because you spend it onboarding users, not regression-testing. Push for 90 days, or a tiered model with a shorter full-scope window followed by a longer critical-bugs-only window.
Does a standard software warranty cover bugs caused by third-party API changes?
No. Standard warranty clauses explicitly exclude failures caused by third-party services (shahnur.software). If Stripe, Twilio, or OpenAI change something and your feature breaks, the fix is billable new work unless you have negotiated a separate support agreement that covers integration maintenance.
Does the warranty cover AI model drift after launch?
Almost never. Warranties are written against acceptance criteria measured at a single point in time, and drift is a post-acceptance phenomenon by definition. Peer-reviewed research found temporal performance degradation in 91% of model–dataset combinations tested (Lumenova AI citing Nature). If AI is in scope, negotiate a separate schedule covering monitoring, performance thresholds, and remediation.
What is a "deemed acceptance" clause and why does it matter?
It is a clause that treats acceptance as complete if you do not formally reject the deliverable within a set window, typically 5 to 10 working days, or if you start using the software in production (fixology.co.uk). It matters because the warranty clock starts at acceptance — so missing the rejection window silently costs you weeks of coverage.
How much should post-launch support cost as a monthly retainer?
The cost model is driven by response SLA (hourly vs next-business-day P1), coverage hours (business hours vs 24/7), scope (bug fixes only vs minor enhancements included), whether AI monitoring is in scope, and who is responsible for cloud infrastructure. A business-hours retainer for a lightly-used MVP is in a very different band from a 24/7 retainer for a consumer product with active model monitoring. The three specifics that turn the range into a real quote: availability requirements, number of live integrations and AI components, and whether the vendor owns infrastructure response. Any serious vendor will scope this for you in a short call.
Sources & further reading
- 7 Clauses Every Software Development Contract Needs — shahnur.software
- Software Warranty Periods in 2026: How Long Should You Fix Bugs for Free? — developer.law (Story LLP)
- Software Development Contract UK: Who Owns Code — fixology.co.uk
- Landmark Commercial Court Judgment on SaaS and Sale of Goods (Kompaktwerk v LivePerson [2024] EWHC 2278) — OEC Law
- Software Development Agreements for UK SaaS Startups — Sprintlaw UK
- Model Drift vs. Concept Drift: Detection & Mitigation for 2026 — Lumenova AI (citing Nature Scientific Reports)
- AI Model Drift and Performance Risk: Detection, Governance — GAICC.org (citing McKinsey & IBM)
- Cost of Defects in Software Testing: 2026 Data & Multipliers — ContextQA (citing IBM SSI & NIST)
Get one practical guide a week
Costs, AI tools, partner selection — written for people who make the decision. No spam, unsubscribe anytime.
Thanks — you're on the list. One practical guide a week, nothing else.
That didn't work — please check the email address and try again.
Building something in Software & Technology?
CodeNicely partners with founders and tech teams to ship AI-native products that move metrics. Tell us about the problem you're solving.
Talk to our team Book a 30-min call_1751731246795-BygAaJJK.png)