Everything warranty touches, on one record.
One record, from the order arriving to the defect data coming out the far end. Coverage resolves against real order data. Four teams work the same claim. And the analysis is done before anyone opens it.
Coverage rules, a customer portal, and claims management.
That’s warranty management: three working parts on one warranty record. The rest of this page is each of them doing its job.
Coverage rules.
Your warranty policy, written as rules the system can enforce. Rules match on SKU, product type, category, vendor, or title — include or exclude, simple or compound — and carry the coverage term. The coverage audit shows every product as covered, excluded, or in a gap before anything publishes, and a registration locks its terms the day it’s made.
The customer portal.
The branded page your customers use. They look up an order, register the product, see what’s covered and until when, read your warranty policy, file a claim with photos, and follow it to a decision — self-service, against real order data, in your brand.
Claims management.
The workspace your team runs. Claims arrive structured and already analyzed; your team reviews, requests what’s missing, records the assessment, keeps the customer conversation on the record, and approves or rejects. If the item has to come back, return receipt and inspection are stages on the same claim — nothing moves to a spreadsheet.
Here’s what it takes to stand them up.
The software takes an afternoon.
The rest we help with.
Connect your store, write your coverage rules, share one link. That part is an afternoon. Deciding what your warranty actually covers usually takes longer, because most companies have never written it down in one place. You won’t need a consulting firm for any of it, and we help you get set up, at no charge.
Most brands run warranty on a form, a spreadsheet, and an inbox nobody wants to own. The alternatives are a registration form at $9–29 that can’t process a claim, or an enterprise warranty suite that starts with a discovery call and ends with a six-figure quote. warrantini is the thing in between: software you can have running the same day, and people who will help you get the rest of the way without selling you a service.
- 14-day trial. No credit card.
- No implementation fee, no statement of work, no partner to hire.
- Setup help is included, and free. We have no services to sell you.
What an implementation actually consists of
- Initial setup. Your team, your preferences, and the portal’s configuration — branding, copy, and the fields your customers see.
- Connecting your data. Products and orders, through a connector, the ingestion API, or an assistant over MCP.
- Your warranty policies, and the rules that encode them. Gathering what you currently promise — usually written in more than one place — and turning it into coverage rules. The preview shows exactly what each rule covers before anything publishes.
- Workflow. How claims move through your departments now that there’s a system: who reviews, who approves, what escalates, what the warehouse records.
- Publishing. The hosted portal on your own branding, or the same engine behind your own site.
- Integrations, when you want them. CRM, engineering, financial systems, the data warehouse — over the REST API, webhooks, or MCP. Optional, and not on the critical path.
Steps 1, 2 and 5 are software, and they’re quick. Steps 3 and 4 are decisions about your own business, and that’s where the time actually goes. Step 6 is whenever your team is ready. We assist with all of it, at no charge.
We’ll show you how we use an assistant
We use Claude the way we’d want you to: to do in an hour the parts that used to take a week. Loading a product catalog. Reconciling a SKU list. Finding the products no rule covers. Our MCP server exists partly so this works, and we’re happy to show you how we do it. It isn’t a service line. It’s just how we think this work should be done now.
Four teams touch a claim.
One record follows it.
Customer service, supervisors, the warehouse, and quality engineering all work the same claim — with the customer conversation on it rather than in somebody’s inbox. Everyone picks it up already knowing what happened.
Warranty is the rare process that crosses every function in the company and usually has no system of its own. Support owns the customer, the warehouse owns the box, quality owns the verdict, and the record of what happened lives in a thread nobody else can see. warrantini gives the claim itself a home: one timeline, every actor stamped, the customer’s exchange included, and the structured defect data falling out the far end for the people who need to fix the product.
Every claim generates an exchange — we need a photo of the label, here it is, we need the serial number, it’s under the lid, we’ve shipped the replacement. In a shared inbox that exchange is scattered across threads, invisible to whoever picks the claim up next, and gone entirely when someone leaves. Here it is one thread on the claim itself. An information request goes out and the reply comes back onto the record.
Two views of one record, and the boundary is enforced in the query, not the interface. Your customer sees their own thread and the status history. Internal notes, defect assessments and inspection findings are filtered out at the database accessor, not hidden by a screen that might leak them. So staff can be candid on the record instead of starting a private thread in email.
Customer service
Takes the claim in, reviews it against coverage, and runs the exchange with the customer.
A supervisor
Picks up what gets escalated — by judgment, by AI signal, or by the clock — and assigns it.
The warehouse
Records the returned item’s arrival and the inspection outcome: pass, fail, or partial, with notes and a disposition.
Quality and engineering
Get the structured defect data out the other end — category, root cause, severity — and the patterns across it.
Each stage hands to the next inside the same claim, with the coverage terms, the customer’s words, the photos, the AI reasoning, and every prior decision attached. Nobody re-keys anything into a second system, and nothing is re-explained in a meeting.
- One append-only timeline per claim — status changes, notes, attachments, customer replies, and AI decisions, all with actor and timestamp.
- Information requests and customer replies land on the record, not in an inbox.
- Internal notes and inspection findings are filtered from the customer view at the query layer.
- Return receipt and inspection outcome are stages in the claim, not a separate spreadsheet.
Six judgment calls, made
before anyone opens the ticket.
Claims arrive classified, with the defect assessment pre-filled, a resolution recommended, and five comparable past claims to check it against. Your analyst decides. Every recommendation is recorded with its reasoning, and every time you overrule it, that becomes the training signal.
Four teams, one record. By the time the first of them opens it, the reading is already done.
The pitch in this category is usually a chatbot that answers your customer faster. That solves a queue problem, not a warranty problem. The hard part of a claim is judgment — is this a defect or misuse, is it covered, repair or replace, and is it the fourth one this month on the same product line. warrantini does that analysis before a person opens the claim, hands them the reasoning, and gets out of the way. Nothing auto-resolves unless you decide it should.
Assessment intelligence
Reads the claim and the product history and pre-fills the defect assessment — defect category, affected area, usage context — each with a confidence figure. Your analyst accepts, edits, or ignores it. It can only choose from your own configured options; it cannot invent a defect category.
Resolution recommendation
Proposes repair, replace part, replace full, or refund — with a one-sentence rationale on the defect, the cost, and the coverage position, plus up to five similar past claims and what you decided on those. It shows its work; you make the call.
Rule recommendations
Reviews 90 days of claims against your coverage rules and suggests adjustments — a gap, an over-broad rule, an exclusion worth adding. Accept or dismiss.
Defect pattern detection
Watches across claims for clusters, rate spikes, seasonal patterns, and batch issues. Surfaces them; changes nothing.
Claims triage
Every claim is classified on arrival for complexity, likely validity, and anomalies, then routed with a recommendation attached. That much always happens. Auto-approving or auto-rejecting is off by default — you enable it, and you set the confidence threshold it has to clear. Most teams run it as routing and never turn the rest on, which is a perfectly good outcome.
Escalation intelligence
Decides when a claim needs a supervisor rather than waiting on a fixed clock: earlier for a safety signal or a high-value product, later for something simple nobody has looked at yet. The time-based thresholds stay in place underneath as a backstop, so nothing gets lost if the AI stays quiet.
- Every decision is a record. Inputs, reasoning, confidence, model, and latency — written to an immutable decision record. You can read why it said what it said, months later, in front of a customer or an auditor.
- Your override is the point. Accept, modify, or overrule, and that outcome is appended to the record. That is the feedback loop: it learns your products and your judgment, not warranty in general.
- It shows its work. Recommendations arrive with precedents — real past claims of yours and how they went. A number with no reasoning is a guess with a decimal point.
- It is constrained to your vocabulary. Suggestions can only use the taxonomies you configured. No invented categories, no drift.
- It cannot block you. Circuit breaker after repeated failures, automatic manual fallback, and claim submission never waits on a model. If the AI is down, the product is not.
- It is in the decision path, not a chat window. The category’s flagship AI is a customer-facing chatbot resolving claims in under a minute. Fine for a standardized protection plan; wrong for a manufacturer warranty, where the value is spotting a seam failure on one product line before another four thousand units ship.
A warranty system that can’t
see the order can’t say no.
Connectors for the platforms you sell on, an ingestion API for anything else, and an MCP server so an assistant can do the loading. Wherever the sale happened, it lands in the same record.
Coverage can’t be checked, a registration can’t be verified, and a fraudulent claim can’t be caught unless the order behind it is in the system. Registration resolves against a real order line item. You cannot register a product nobody bought, and no more looking up orders. Coverage dates lock at registration and never move. The same item can’t be registered twice. All of that depends on the data being in. Getting it there is the first thing we do, not a project you run.
More than half of consumer brand sales happen through retail or a marketplace, and most brands run an ERP that never talks to their storefront. A warranty tool wired to a single platform is structurally missing most of the claim volume. For exactly the brands that have the most of it. warrantini normalizes every source into one order and line-item record, and anchors coverage to the source platform’s own identifier, so changing a connector years from now doesn’t orphan a single warranty.
- One canonical record regardless of source — same coverage rules, same claims workflow, same audit trail.
- Coverage anchors to the upstream line-item ID for the full 1–10 year life of the warranty.
- A unit sold through a retailer or marketplace carries the same coverage as one sold direct.
The connectors we provide
- Shopify
- Amazon Selling Partner
- BigCommerce
- WooCommerce
- Adobe Commerce
- NetSuite
- SAP S/4HANA Cloud
- SAP Business One
- Dynamics 365 Finance & Operations
Not on the list? POST /v1/orders takes data from any system, at whatever cadence you already run. Either way the connector is free, and so is help getting it running.
Every claim is a data
point about your product.
Analysts record defect category, affected area, and usage context. Inspectors record confirmed defect, root cause, severity, and disposition. Both run on lists you define, and the platform surfaces the clusters, the rate spikes, and the batch issues.
A claim is usually treated as a cost to process. It’s also the highest-fidelity quality signal a brand ever receives: a customer telling you precisely how your product failed, with photos. Most warranty tools throw that away and store a status. warrantini captures it as structured data on every claim, then looks across all of them for the pattern you’d otherwise find a quarter too late.
- Every taxonomy is yours to define, so the categories match how your team already talks about failures.
- Pattern detection across defect clusters, rate spikes, seasonal patterns, and batch issues.
- A year of claims becomes an answer about your own products. Most warranty tools store a status.
Use our screens,
build your own, or both.
Headless means the product’s data and logic are separated from its screens. warrantini ships with a complete set of screens. They run on the same public API anyone else can use, so you can replace any of them with your own and nothing underneath changes.
The proof is not a promise: our customer portal consumes the public customer API. A brand can put registration and claims inside its own site, in its own design system, on its own domain, and it is the same warranty engine answering. Headless parity is a requirement we already depend on, It can’t quietly rot: breaking that contract breaks our own product first.
Turnkey
Use our portal and our dashboard. Nothing to build, and we help you get it configured.
Both, which is the common one
Your team runs claims in our dashboard while your customers only ever see your own site.
Headless
Keep the engine, build your own customer experience — inside your existing site, storefront, or app.
And the third option stays open. Because the portal already runs on the public API, starting turnkey and going headless later is not a migration. The contract you’d build against is the one we’re already using in production. The whole warranty record is reachable that way, not a read-only slice; account administration is deliberately not.
The baseline is usually zero.
That has a price.
Warranty cost runs about 0.8% of revenue at the top quartile and 4.0% at the bottom. On $10M in sales that’s the gap between $80,000 a year and $400,000. The brands at the good end aren’t luckier about defects. They can see them.
Run your numbersTry it on your own orders.
14 days, no card, no implementation fee. Connect your store, write one coverage rule, and see whether it holds up against order history you already know the answers to. If it doesn’t, you’ve lost an afternoon.