Service lifecycle architecture.
Inspect
Fault or coverage confirmed on site before anything is committed
Estimate
Parts, labour & cost drawn up from the inspection
Approve
Estimate cleared against policy or customer sign-off
Execute
Technician completes the job against the approved scope
Invoice
Customer billed for consumables & chargeable labour
Claim
Covered work billed to the principal or insurer instead
Reconcile
Settled claim matched back to the invoice & job record
The workshop, end to end.
Red, amber, green — and revenue
Digital inspection templates with RAG scoring and readings; a red item triggers a rule-driven recommendation the customer accepts or declines — accepted work lands on the job as lines. Identical on web and offline mobile.
One job card runs the whole workshop
Work start to delivery with technician timesheets (standard vs actual hours, pause reasons), parts allocated and picked from real stock, complaint and fault codes, and invoicing — split bills, advances and India-grade tax included.
Warranty claims born from the job card
Claimable lines carry the complaint code, fault code, failed-part treatment and technician — batched and submitted without re-keying. A configurable claim engine generates claims from any document on a schedule, with a simulate mode.
The service book that fills itself.
One job card. Everything hangs off it.
Advisor: Sunita M.
Every claim, from source transaction to settled line.
Claims generate from configured rules, batch by partner and period, and route for approval. Every submitted line reconciles — approved, rejected, or short-paid — and the settlement posts back to finance and stock automatically. Short payments become reclaims, not spreadsheet rows.
The capabilities, stated plainly.
Every row ships today and traces to a capability described on this page.
| Capability | xMatix Service |
|---|---|
| RAG health checks and check-in inspections | Native |
| Estimates with customer approval before work | Native |
| Job cards with labour, parts and status | Native |
| Technician timesheets from the work itself | Native |
| Parts allocation and picking | Integrated — Inventory |
| Structured complaint and fault codes | Native |
| Capability | xMatix Service |
|---|---|
| Invoicing from the closed job card | Native |
| Warranty claims with configurable claim rules | Native |
| Claim settlement with line-level reconciliation | Native |
| Contracts, AMCs and preventive maintenance | Native |
| Appointments and bay planning | Native |
Everything in Service.
RAG health checks
See the problem before opening the bonnet.
A red-amber-green check captures the asset's condition at arrival — expectation set with the customer from minute one.
Check-in inspections
The condition on arrival, on record.
Photos and checklists at check-in — the scratch that was already there stays "already there".
Estimates & customer approval
No work starts without a yes.
Estimates go to the customer for approval before a tool is lifted — the bill is never a surprise.
Job cards
Every job, one card, whole story.
Labour, parts and status live on the job card — anyone can pick it up and know exactly where it stands.
Technician timesheets
Hours flow from the work itself.
Time books against the job as it happens — utilisation is measured, not estimated.
Parts allocation & picking
The part is waiting when the tech is.
Parts reserve to the job and pick from stores in one flow — no technician queuing at the parts counter.
Complaint & fault codes
Failures you can count are failures you can fix.
Structured complaint and fault codes turn anecdotes into patterns — the recurring defect surfaces itself.
Service invoicing
From job done to bill sent, no gap.
Closed job cards invoice directly, labour and parts included — revenue doesn't leak in the handoff.
Warranty claims
Warranty work gets paid back.
Claims raise from the job with the evidence attached — recoverable money stops dying in a drawer.
Config-driven claim engine
Every maker's claim rules, one system.
Each principal's warranty terms configure in, and claims validate against them before submission.
Claim settlement
Track every claim to the money.
Submitted claims track to approval and settlement — you always know what's owed and by whom.
Line-level reconciliation
Reconcile claims line by line.
Settlements match to claim lines individually — the short-paid line shows itself instead of hiding in a lump sum.
Contracts & AMCs
Contract customers never fall through cracks.
AMCs carry their entitlements and schedules — covered work is honored, billable work is billed.
Preventive maintenance
Service before the breakdown call.
Schedules raise the visit before the failure — the asset's downtime becomes your planned work.
Campaigns & recalls
Recalls handled completely, provably.
Affected units identify from records, work tracks per unit — you can show exactly who's been covered.
Appointments & bays
Every bay earning, no customer waiting.
Appointments book against real bay and slot capacity — the workshop runs at its true throughput.
The questions evaluators ask.
Where the work happens. xMatix Service runs work that comes to you — check-in inspections, job cards, bays, warranty and AMCs at your own locations. xMatix Field Service dispatches work to the customer's site — scheduling, road-network routing, geofenced attendance and on-site proof of work. Both run on the same job card and the same data model, so a case can move between the workshop and the field without being relayed. Explore xMatix Field Service.
Run the contract, not just store it: meter entitlements by time, usage hours or readings with grace bands, generate preventive jobs before due dates, raise renewal leads inside the reminder horizon, and decide per job line what is covered and what is chargeable — with every settlement posting to real books. A contract module that only holds the PDF is a filing cabinet with a renewed problem.
Parts and labour on one card with GST treated correctly on each, technician timesheets, customer approval stamped before work starts, the payer decided per line — warranty, AMC, customer-pay — and an invoice that posts to the ledger without re-entry. Field jobs need the same card working offline, because the plant room does not carry signal.
Yes — technicians execute the whole visit fully offline, photos included. Work captured with no coverage queues in a durable outbox and syncs safely when the signal returns, even if the phone restarts first. Geofenced check-in, the activity steps, proof-of-delivery signatures and on-site invoicing all run from the device — the job does not care about the signal, and nothing is lost or relayed.
From one live screen. Dispatchers see technician positions, travelled paths and unassigned jobs as a map, a Gantt timeline or a board, and assign by dragging. "Optimize day" re-sequences a technician's jobs over real roads with one click — the planner approves, the math checks — while capacity and actual availability, and appointment bookings draw from real slot capacity so the calendar cannot overpromise.
Yes, end to end. Claims raise from the job card with the evidence attached, validate against each principal's configured warranty terms before submission, and then track through approval to settlement — so recoverable money stops dying in a drawer. Settlements reconcile to claim lines individually, which means the short-paid line shows itself instead of hiding in a lump sum.
Yes — several layers of it. Check-in passes server-checked geofence gates, selfie included, so time on site is fact rather than a claim. Photos and checklists capture condition on arrival, signatures and photos attach at the moment of completion, and background GPS trails record the route actually driven — captured even offline and replayable on a map when a customer disputes the visit.
Yes. Case-level SLAs run in xMatix Support on the same data model: response and resolution targets track milestone by milestone, against business-hours clocks, with automatic escalation before the breach rather than a report after it. On the scheduling side, appointment windows draw from real slot capacity — the promise made to the customer is one the team can physically keep.
