Deployed
A production console built on one lesson: never let remarks become the status system.
Armoured vehicle production tracking used to live in spreadsheets where "status" was whatever the last editor typed. This system replaces it with a strict stage rail, near-zero write access, and integrity rules enforced by the database itself — closing the loop from sale to delivery.
What changed
- Before
- Production status lived in free-text spreadsheet remarks that no one could aggregate.
- Now
- Every vehicle on a 14-stage rail, written by two roles and read by everyone.
System facts
July 2026 — deployed build
- Production stages
- 14
- Roles with write access
- 2
- Read views
- 5
- Write RPCs — the only way in
- 3
Next.js frontend on a Supabase backend, deployed via Vercel. Vehicle- and lot-level production paths, per-unit status splits, project overview and decision dashboards. Production data and client details are not shown here.
The problem
Production status lived in spreadsheets: free-text remarks, no shared stage definitions, no way to aggregate where dozens of vehicles actually stood — and management decisions waiting on information that had to be collected by walking the floor.
The constraint
The replacement had to stay trustworthy under real organizational pressure — many viewers, strong incentives to "adjust" statuses, and delivery deadlines counted per unit. Trust was designed in structurally, not requested politely.
The flow.
- New order created with project + unit breakdown (RPC, production head only)
- Vehicles / lots enter the 14-stage production rail
- Stage updates via single or bulk RPC — no free-form status
- Views aggregate: KPIs, project summary, stage distribution
- Open decisions surfaced on the decision dashboard
- All roles diagnose from the same live picture
Six decisions that define the system.
Every one of them is a container for the same failure mode: data that drifts from reality the moment humans are busy.
- 01
Status is a position on a rail, not a remark
Every vehicle sits at one of 14 defined production stages. The dashboard renders the rail per vehicle and per lot; stage distribution views roll it up per project.
Why not the obvious alternative
The previous tracker died by free-text: "almost done, waiting on glass" means nothing you can aggregate. The system's stated core principle is that free-form remarks must never become the status system again — that is how Excel escaped containment the first time.
- 02
Almost everyone can look; almost no one can touch
Viewer and production-user roles get full diagnostic dashboards. The Update and New Order surfaces are restricted to production-head roles (admin, production_manager) — two roles, out of everyone.
Why not the obvious alternative
Shared-write is what corrupted the spreadsheet era: every editor a potential source of fiction. Inverting the default — universal read, near-zero write — keeps the data trustworthy enough that management actually uses the dashboard instead of phoning the factory floor.
- 03
The database enforces the rules, not the UI
Reads go through dedicated views (KPIs, project summary, vehicle status, stage distribution, open decisions). Writes only happen through RPCs — create_project_with_units, update_vehicle_stage, bulk_update_vehicle_stage.
Why not the obvious alternative
UI-enforced rules last until the next UI. Pushing integrity into the database layer means no client, script, or future rewrite can put a vehicle in an impossible state. The frontend is deliberately replaceable; the contract is not.
- 04
Units are the primitive — again
Projects decompose into vehicle- and lot-level production paths; KPIs and status counts are split by units. The same unit-first modeling as the CRM, applied downstream.
Why not the obvious alternative
A project-level "70% complete" hides which specific vehicles are stuck at which stage. Contract deadlines are per unit delivered, so the tracking primitive matches the contractual one — consistent with how every system I own models this business.
- 05
A decision dashboard, not just a status dashboard
Open decisions are a first-class view — the things awaiting a human call surface on their own panel instead of hiding inside status notes.
Why not the obvious alternative
Production stalls are usually decision stalls. Tracking the stage tells you where a vehicle is; tracking open decisions tells you why it isn't moving. The second question is the one management meetings are actually about.
- 06
Calm UI, strict security hygiene
Apple-style light dashboard language: restrained status colors, segmented navigation, a large calm operational header. Browser-exposed config carries publishable keys only — service-role keys are explicitly barred from the frontend environment.
Why not the obvious alternative
An ops room screen read twenty times a day earns calm design; alarm-colored dashboards train people to ignore them. And the key discipline is the difference between "works in the demo" and "safe to deploy" — written into the setup docs so it survives handover.
Stack
- Next.js
- Supabase (Postgres, RLS, RPC)
- Vercel
- React
Want the deeper walkthrough?
I can walk through the stage model, the view/RPC contract, and why write access is the scarcest resource in the whole system.