Warranty management.
Surprisingly smooth.
Your warranty policy, written as rules the system enforces. A branded portal your customers register on. A claims workflow your team actually runs. An API your engineers can build against. Coverage stops being a page and becomes a record.
rul_24mo_hardgoodsWarranty lives in three places that were never built to hold it.
A PDF form on the site. A spreadsheet one person maintains and nobody else can open. An inbox where claims go to age quietly. Ask who’s covered right now, which product line is failing, or how long a claim really takes. Nobody knows. Not because your team is careless. The answer was never written down anywhere.
No source of truth.
Refunds get approved on coverage that lapsed months ago.
No workflow.
Claims move when somebody remembers them.
No signal.
The defect pattern is sitting in the inbox, and nobody can see it.
Three working parts. One record underneath.
One product replaces the form, the spreadsheet, and the inbox. Three parts sharing one record, so a question asked anywhere gets the same answer.
Coverage rules.
Your warranty policy, written as rules the system enforces. Match on SKU, product type, category, or vendor; set the term; see exactly what’s covered, excluded, or in a gap before you publish.
A customer portal.
The branded page your customers use — register a product, check what’s covered and until when, read your warranty policy, file a claim with photos, follow its status. Against real order data, without emailing anyone.
Claims management.
The workspace your team runs. Review and assessment, the customer conversation, approve or reject. And when an item comes back, receipt and inspection land on the same claim.
Three steps. One afternoon.
Help if you want it.
Connect.
Pick your platform — storefront, marketplace, or ERP — and your orders and products sync automatically. Not on the list? Push them to one endpoint. The connectors are free either way, and so is help getting it running.
Set coverage.
Write rules that match on SKU, product type, category, or vendor, and set the term each one carries. That’s your warranty policy, in a form the system can act on.
Share the link.
Customers register and file claims on a portal in your brand. Each one arrives classified and routed.
That’s the portal live. A full rollout also takes in your policies, your team’s workflow, and any systems you want it wired into. We help with all of it, at no charge.
Every claim arrives already analyzed.
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.
- Six decision points. Four only ever suggest.
- Auto-resolution ships off. You enable it and set the confidence bar.
- Every decision recorded with its reasoning, its confidence, and the model. A number with no reasoning is a guess with a decimal point.
A claim is not a ticket one person closes.
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.
- 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.
- Return receipt and inspection outcome are stages in the claim, not a separate spreadsheet.
- 21 REST endpoints · 19 MCP tools · 13 webhook events · 9 scopes.
- Test and live keys separated at the credential; a real sandbox on an isolated database branch with seeded data.
- 90-day minimum sunset with
Deprecation/Sunsetheaders — a written commitment, not a policy page.
Sell everywhere.
Cover everywhere.
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.
- A warranty system that can’t see the order can’t say no. Registration resolves against a real order line item: no more looking up orders.
- Coverage anchors to the upstream line-item ID for the full 1–10 year life of the warranty.
- Not on the list?
POST /v1/orderstakes anything, with idempotency keys.
See the pattern before
it becomes a recall.
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.
- 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.
Two ways most people end up here.
DTC brands
You sell direct, your store is already good software, and warranty is the one part of it running on a shared inbox and somebody’s spreadsheet. Ops and CX leads get one queue and one status, with claims triaged before anyone opens them. Founders get a portal that looks like the store rather than like a vendor.
For DTC brands →Manufacturers
You sell through retailers, marketplaces, and distributors, so the warranty record has to survive a channel you don’t control. And the customer honoring it is often someone you’ve never met. Push orders from any system to one endpoint, anchor coverage to your own line-item identifier, and get defect data back on taxonomies you define.
For manufacturers →Three different products answer to the word “warranty.” Only one of them is this.
- Protection plans
- Sell your customer a third-party contract and pay you a share. They don’t touch your own warranty. Plenty of our customers run both.
- Enterprise warranty suites
- Implementation projects for OEMs and dealer networks. If you have a warranty department, they’re built for you. If you have a warranty person, they aren’t.
- Registration apps
- Collect a form submission. No claims workflow, no API, and no view of anything that isn’t a Shopify order.
warrantini is warranty operations: the record, the workflow, the intelligence, and the contract.
The honest answers.
Isn't $49 too inexpensive to be credible?
Fair question. Registration forms are $9–29. Purpose-built claims software with public pricing starts at $549. We're a category jump priced against the bottom and a category discount priced against the top — and it's the same product on both sides. 14 days free, no card. Inexpensive is easy to test.
We use Zendesk / Gorgias / Re:amaze for this.
Support desks are built for tickets, not warranty state: coverage terms, return workflow, defect assessment, replacement registrations, immutable event history. You're paying $55–150 per agent per month for a tool doing a job it wasn't built for. We're $49–399 flat. A ticket closes. A warranty runs for years.
Which platforms do you connect to?
Shopify, Amazon Selling Partner, BigCommerce, WooCommerce, Adobe Commerce, NetSuite, SAP S/4HANA Cloud, SAP Business One, and Dynamics 365 F&O. Anything else pushes to POST /v1/orders — the ingestion API takes any channel, and plenty of merchants use it by preference. Whichever it is, the connector is included on every plan, and so is help getting it running.
What does implementation actually involve?
Six steps. Your initial setup — team, preferences, portal configuration. Connecting your product and order data. Gathering your warranty policies and turning them into coverage rules. Deciding how claims move through your departments. Publishing the portal, or putting it behind your own site. And optionally wiring it into your other systems — CRM, engineering, finance, the warehouse. Steps 1, 2 and 5 are software and they're quick; 3 and 4 are decisions about your business, and that's where the time goes. We assist with all of it, at no charge.
What about security and data?
Postgres row-level security enabled and forced on all 26 tables — tenant isolation enforced by the database, not by application code. Per-tenant HMAC-signed webhooks. Immutable audit trails on every claim, registration, and AI decision. GDPR request handling in place. Every tier gets the full surface; there is no security upsell.
You're a startup. What if you go away?
Two answers, and the first is structural. warrantini is developed and operated by MGP Labs, a division of Mahusai Global Partners — a consulting firm that has spent fifteen years inside the operations of Fortune 1000 industrial companies. It builds its software with its own capital: no fund timeline, no exit pressure. The second is evidence rather than assurance: your orders, registrations, and claim events export through the API any time you like. We'd rather be worth staying with than hard to leave.
Warranty operations,
sorted before dinner.
Free for 14 days. No card, no implementation fee, no statement of work. If you get stuck, we’ll help you get set up. There’s nothing to buy at the end of it.