Building the operations stack for working fleets
Three coordinated surfaces for a working fleet — a native iOS driver app, a live web dispatch console, and an AI mechanic wired to Shopify parts inventory — built because the existing fleet stack is a stack of single-purpose SaaS tabs that don't know about each other.
Most fleet stacks are three SaaS tools wearing one logo. TunedIN is one event log surfaced three ways. Driver mobile, fleet web, and the AI mechanic are all readers and writers against the same stream — when a driver accepts a job, dispatch sees it; when the truck emits a DTC, the mechanic agent sees it; when the agent orders a part, the dispatcher sees the ETA. The single source of truth is what makes the surfaces feel coordinated instead of integrated.
Fleet operators today live in five tabs at once. Dispatch in one tool, fuel cards in another, routing in a third, mechanic notes in a notebook on a desk somewhere, parts ordering in a fourth tab that's actually just an email thread with a vendor. Each tool optimizes its own surface and assumes the others don't exist. The driver, the dispatcher, and the mechanic end up doing the integration work in their heads — which is exactly the work software should do.
The cost of that fragmentation isn't abstract. A diagnostic code that fires at 7am on a Tuesday gets noticed by the driver, ignored because the dispatch screen doesn't show DTCs, escalated three days later when the truck won't start, and finally resolved a week after that when someone remembers which vendor stocks that part. Every step of that chain is software-shaped. None of it is software-served.
TunedIN is one platform with three surfaces, not three products with shared login. The driver app is a native iOS build because dispatch + clock-in + routing has to work offline in a yard with no signal — a web app would feel borrowed. The web dispatch console is what the operator actually runs the day from: a live map of every active unit, an assignment queue, and a roster table that updates in real time as drivers accept jobs and clock in. Both surfaces talk to the same event log, so a state change on one shows up on the other in under a second.
The AI mechanic is the wedge. Vehicles emit CAN-bus DTCs all day; most are noise, some are urgent, and the difference is exactly the kind of pattern an LLM is good at learning when given enough fleet history. The mechanic agent watches the event stream, classifies severity (info / watch / act), surfaces a recommendation in the dispatch console, and — when the recommendation involves a part — looks up SKUs against the Shopify inventory and auto-orders the right one. The ops manager sees a line, not a fire drill.
The integrations are the moat. Shopify for parts. Stripe for payouts. Twilio for driver SMS. CAN bus telematics through a hardware vendor on the truck. Each one is plumbing work, but together they're what turns 'fleet management software' into 'an operations system that actually runs the fleet.'
The mechanic agent queries Shopify for SKU availability and places orders directly when a recommendation is approved. Parts ETAs come back as confirmed ship-by dates, which appear on the dispatch console next to the affected unit.
Truck-mounted telematics modules emit DTCs and engine-state events into the platform's event log. The mechanic agent subscribes to that stream; the dispatch console renders the live state.
Clock-in events from the driver app feed Stripe Connect for per-shift payouts. Drivers see their balance update in the app the moment they clock out — no end-of-week reconciliation.
Critical dispatcher notes (route changes, hold orders, mechanic-flagged DTCs) reach drivers through SMS even when the app is closed. The same message body is logged to the event stream so the audit trail is complete.
Drivers get a native app that works offline in a yard with no signal: live job queue, one-tap accept, clock-in tied to GPS, turn-by-turn routing to the next stop. Push notifications come from the same event log the dispatch console reads, so a job appears on the driver's lock screen at the exact moment the dispatcher assigns it.
The dispatch console is the operator's daily driver. A live map shows every active unit on its current route; the roster table updates as drivers accept jobs and clock in; the assignment queue lets the operator hand a job to the closest available driver with a single drag. Every state change is sub-second because there's only one event log to watch.
The mechanic agent watches the CAN-bus event stream, classifies each DTC as info / watch / act, and surfaces a recommendation in the dispatch console with the reasoning trail attached. When the recommendation involves a part, the agent looks up the SKU against Shopify inventory and auto-orders the right one — the operator sees a confirmed ETA, not a phone call to make.
Driver mobile, fleet web, and the mechanic agent are all readers and writers on the same append-only event stream. State on one surface is state on every surface. The integration work that fleet operators today do in their heads is moved into the platform — which is the entire point.
SwiftUI build with offline-first dispatch, GPS clock-in, and turn-by-turn routing. Tested daily by working drivers on real routes.
Next.js console with live map, roster, and assignment queue. Sub-second updates from the same event log the iOS app reads and writes.
DTC triage with severity classification and Shopify SKU lookup. Recommendations come with reasoning trails; approved orders ship without a phone call.
© 2026