All work

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.
Order → delivery14-stage rail0102030405060708091011121314Stage updates via RPC only5 views · 3 RPCsStalls get flagged

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.

  1. New order created with project + unit breakdown (RPC, production head only)
  2. Vehicles / lots enter the 14-stage production rail
  3. Stage updates via single or bulk RPC — no free-form status
  4. Views aggregate: KPIs, project summary, stage distribution
  5. Open decisions surfaced on the decision dashboard
  6. 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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

Next breakdown B2G Procurement Data Extraction Workflow