Operations orchestration, every capability typed and reachable.
Sync · Validate · Orchestrate · Ship
Start here New? Read the 1-minute explanationKnow your way around? Jump straight in:
What is this?
ServiceProof takes the work your business already schedules — a work order, a delivery, an inspection — and delivers it to the person doing it as a conversation on their phone: WhatsApp, RCS, Apple Messages, SMS. No app to install, no login to teach. They answer questions, snap photos, sign, tap done — and every tap lands as structured, queryable data: timestamped, GPS-stamped, attached to the right customer and equipment, with a customer-ready PDF at the end. (A full mobile PWA and web runner stand behind the thread for the steps chat can't render.)
It sits beside your existing systems, never in place of them. Your ERP / CRM / ServiceTitan stays the system of record: ServiceProof syncs in the records the field needs, adds what the field learns, and hands the results back — through ServiceProofSync (near-real-time, bi-directional, on-prem or hosted) or through as little as a job number in and a webhook + PDF out. Start shallow, go deep when it earns it.
And every capability has two faces on one contract: the form an office user fills in is the endpoint your integration POSTs against — same validation, same rules — and the same surface is a typed MCP tool, so an AI agent can discover your schema, read what the field captured, and dispatch work the way a person would. One contract, three audiences: humans, integrations, agents.
The Twelve Pillars
Why it's built this way
Most platforms ask you to integrate first, then read state back out. We flip it. When a field tech taps started job, paused for parts, or delivered on their handset, that tap is the data — a timestamp, a photo, a signature, a GPS fix, attached to the entity, queryable forever, with nothing to read from and nothing to reconcile. That posture is why the platform is shaped the way it is, and why the API is shaped the way it is.
Records sync in from ServiceTitan / ERP / CMMS, the field and office add what they learn, and the results push back out on milestone completion. We enrich, validate, route, and surface — we don't replace your systems of record.
Pillar 3 — the Context Engine — hydrates an anchor record's whole neighborhood (parents, children, lookups, scoped reports) into one [[ ]] bundle every workflow, form, surface, and email reads identically. One definition, every surface.
The integration floor is a job-number key, an outbound webhook on milestone completion, and a PDF proof packet to the customer. No deep two-way sync required to get value on day one.
The multi-section form an office user fills in is the exact endpoint your integration POSTs against — same validation, locked defaults, conditional-visibility-aware required checks, composite-key inheritance.
A workflow is authored once and rides the field three ways — RCS / Apple Messaging / WhatsApp / SMS over Infobip first, the mobile PWA and web runner as the full-featured fallback when a step can't render in chat.
Every Studio action is a friendly-named REST endpoint, and the menu hierarchy doubles as an MCP agent's tool dictionary. An agent can author a surface or run a report the same way a person can.
Pillar 12 — Field Experience
Eleven pillars build and deliver the workflow. The twelfth is the one your field crew actually feels: how the run reaches a human. One authored workflow, one shared run, four ways to experience it — and every face lands on the same rows, so a run can start in the thread, flip to the web for a signature, and finish in the truck.
The crown is Wingman for Workflows — the most powerful thing on the platform. The tech just talks — a voice note, a long rambling text, photos with captions, straight into the same WhatsApp thread — and Wingman, knowing the whole workflow definition, extracts properly-typed answers and fills step after step in one pass: “PKZIP for workflows.” It never asks past what the workflow's structure allows. What the run isn't ready for, it stashes for the moment the run gets there. Every photo it's owed becomes a catalogued debt — “you owe me ONE PHOTO of the blower motor” — held by a branded placeholder that the completion honesty gate guarantees is replaced before the run can finish. Every fill rides the exact same validation a typed reply gets: a smart typist, never a second runner. Signatures always open the browser — no voice, no placeholder, no exception.
Then add the Wingman Earpiece — and for the trades, this is the game-changer. The phone goes in the pocket: the run is read aloud turn by turn and the tech answers out loud — both hands on the wrench, eyes on the equipment, paperwork finishing itself in their ear. And underneath? It is still all orchestrated over rich messaging — the same thread, the same run, the same validation, the same audit trail. One brain, many mouths.
And the earpiece doesn't just hear — it knows your business. Before a word is spoken, its ears are taught your world: the menu, the commands, your customers and equipment in the tech's own language — and the moment a job is live, everything about that job: the work order, the customer, the address, every answer the next question will accept. So “what do I do today?” opens the to-do list, “the second one” taps the second button, and a spoken work-order number arrives as the real key, dashes and all — matched against what the platform is expecting, never guessed. And when a mishear sits between two close options? It refuses to pick, and asks. Honesty, even in the ears.
The full WASM field app — offline outbox, GPS + geofence, camera, metro-tile home. Built for patchy LTE and gloves on.
Office workers and QA-ing field leads running the same workflows in a browser on Windows / Mac — plus the web-flip target when a step needs a real screen.
The run lives entirely in the conversation — turn-by-turn over WhatsApp / RCS / SMS. No app to install, no login to teach.
Speak or dictate — one voice note fills many steps; debts collected, completion honesty-gated. Phone in the pocket, hands on the work, the thread as the record.
The platform's own intelligence
The platform quietly studies how your business fits together — which customer owns which location, which equipment lives at which site, which keys your people actually work with — and keeps that knowledge current on its own. So when a person, an integration, or an AI asks a question, the answer is already assembled and already correct. That's the difference between an assistant that fumbles and one that runs your operation like a dream — and most of it needs no AI subscription at all.
Answers come back instantly because the platform remembers what it already assembled — and it re-checks that memory the moment your data actually changes, so a fast answer is never a stale one. It even warms up ahead of your busiest users. You manage none of it.
It notices which customers, work orders, and equipment each person actually touches, and remembers — per user, with confidence. Ask “pull up the Hendersons’ unit” and the assistant starts from what it already knows is yours. No re-lookup, no guessing.
POST /api/v1/context/recommend reads your schema and drafts ready-to-save relationship maps. The loop is recommend → save → hydrate — no binding grammar to learn. The same capability is a Copilot/MCP tool, and an optional AI pass refines it.
Most tenants run without an AI subscription, so the platform's deterministic ranking + key/name compare powers conversational add / list / relate / query over messaging with zero AI. When a tenant does bring a key, the AI stands on this same intelligence.
An MCP agent can resolve_identity a person (an employee key, an email) to their platform user and pass acting_as to see their worklist — “show me Alan's dispatches” — then revert. Read-only scoping through the identity bridge; no privilege change.
A saved cross-entity report — totals, trends, time-travel, the works — can ride along inside the same picture as the customer and their equipment. A workflow, an email, or a page can quote a report number as easily as a customer name.
The Platform Surfaces
Schema, data, forms, and the field + messaging layers — each reference doc stands alone, so you shouldn't need to bounce between them to do one thing.
Design the shape of your data. Entities composed of typed properties, language displays, catalog import.
Single + bulk upsert, list, pivot, views, per-instance variance and time-travel against the schema you designed.
Chained joins, conjunctive filters, aggregates (SUM/COUNT/AVG/MIN/MAX), variance over cadenced snapshots.
The most user-facing surface. Hierarchical multi-section, atomic multi-save, validation parity with the Portal.
Workflow + step CRUD, branching, duplication, reordering. Field-side companion to your back-office data.
Upload, signed URLs, stream-through proxy, Azure Blob / S3 / Google Drive / SFTP across 14 provider types.
Create, list, update preferences + contacts, lock/unlock, find-or-create with auto-provisioning.
Provision tenants, configure SMTP / languages, send invites, manage tenant-wide policies.
Pillar 3 — the logic layer. Hydrate an anchor record's related data (parents, children, lookups, scoped reports) into one [[ ]] bundle every other surface reads.
Pillar 8 — tenant-authored pages from one LayoutJson that render on Portal + Mobile + RCS. 35 section kinds, 5 anchor sources. Author once, render everywhere.
Pillar 10 — send + read over WhatsApp (live) / RCS / AMB / SMS via Infobip. Text, buttons, list, CTA-URL, image, location, plus the unified inbound log. The handset delivery layer.
The send → await → poll → end agent loop. converse (send + durable ordered inbox) and ask (bounded inline wait for a confirm / approve / proof reply).
Pillar 9 — install + configure trigger-driven packs and read the Action Center run log. 10 trigger types (OnDemand / Timer / Webhook live); run, simulate, inspect every step.
Offline-first IndexedDB + sync outbox, optimistic UI, GPS + geofence, a forms runner with binary capture, metro-tile home + drawer menu. The full-featured workflow backstop.
Read these four first
Twenty minutes here saves hours of trial-and-error later. UTC always, friendly names everywhere, language fallback by design.
Token → whoami → one working write. Five minutes. Your first round-trip end-to-end.
Session tokens vs long-lived API keys. Scopes, role flags, rotation, what the bearer carries internally.
UTC dates with Z, friendly idOrName, pagination, error envelope, language fallback.
Tenant vs tenantUser vs user, entity vs instance vs property, workflow vs step. Small file, big payoff.
Tooling
Treat them as the canonical "here's a working integration" and copy the patterns that apply.
Plug ServiceProof into Claude Code, Cowork, ChatGPT, Replit, or your own agent: one URL + your API key = the full doc library plus 222 platform tools. Your AI reads the docs, then drives the platform — discovery, data, jobs, answers.
Drop in your API key, pick any of 424 endpoints from the Postman tree, fire a real request, see the response. No tool install needed.
80+ canonical request/response examples extracted directly from the integration test harness. Every JSON body verbatim from a passing assertion — copy-paste safe.
424 requests across 29 folders. Set baseUrl + apiKey and run anything in your terminal of choice.
Foundation .NET console + Windows Service. Fork the connector, deploy as a service, monitor via EventLog. Win / macOS / Linux.
11 real-world patterns end-to-end: webhook intake, nightly RowHash diff, multi-entity parent chain, time-travel, conflict detection.
Three-audience validator (UI + Copilot + integrators), Levenshtein suggestions, the discover → build → validate → save recipe, CI drift detection.
Hash-diff dirty detection, composite-key + parent resolution, bidirectional pull-then-push, locale-safe wire formatting, Serilog & EventLog.
Send and run conversations as a 3rd party over WhatsApp / RCS / Apple. The integrator path is one call — POST /api/v1/messaging/send with an API key — fire-and-forget, send-and-wait, or on-reply callback.
Every console harness, zipped from source. Six are self-contained — unzip, set --base-url + --token, dotnet run. Read the code, fork what fits.
Ready when you are
Five minutes, you have a token and a green response. An hour, you've shipped something real. Pick the door that matches where you are.