Product Design · Notion + Node.js · Live

A repair-shop system that files itself.

A real Navsari repair shop was losing five minutes of copy-paste on every finished job. I designed and built a Notion system with a Node script behind it that cut that to a single status change. Live and in daily use across the team.

My role

Sole designer + engineer. Product, logic, build.

Stack

Notion + Node.js API script

Status

Live, in daily use

Repair Hub cover page in Notion

The problem

Filing a finished repair took five minutes of copy and paste.

The shop tracked active repairs in one Notion database and wanted a permanent, per-customer service history in another. Bridging them by hand was slow and easy to get wrong: duplicate customer profiles, mismatched phone numbers, dropped rows.

The désign question was not how to build a form. It was how to make the filing disappear.

Nobody asked me to fix this. I noticed it by spending real time at the shop and watching the copy-paste ritual happen after every job — the kind of friction a client brief never mentions because it is too routine to complain about.

I pitched the fix unprompted. The owner gave explicit buy-in to build it and to use the shop's real name here.

Before, for every repair

01

Find the right customer, or create them

02

Copy the machine, date, price, and parts notes

03

Paste it into their history table

04

Delete the tracker card so it is not done twice

The screens

Two databases, one bridge that files itself.

Active repair tracker with live customer rows

Active tracker: every incoming machine, live

Completed repairs archived under each customer

Archive: filed automatically under each customer

How I built it

The hard part is invisible. It files itself.

A small Node script talks to the Notion API and polls every ten seconds. When a repair is marked Completed it finds or creates the customer, appends the repair to their history, and archives the card. The interesting part is what breaks at the edges.

01

Log the repair in the tracker

02

Set the status to Completed

03

Script matches the customer by phone

04

Appends to history, archives the card

Problem 01 · Duplicate customers

Notion’s index lags its own writes

Create a customer, then look them up for their next repair in the same batch, and the lookup can miss the profile you just made. It creates a duplicate. I keep an in-memory cache of everyone created or matched during a run, checked before every API query, so a customer is never created twice in one pass.

Guard before the API querysync.js
// Check in-memory live cache first to avoid Notion's
// eventual consistency index race condition
if (liveCustomerCache.has(cacheKey)) {
  return liveCustomerCache.get(cacheKey);
}

Problem 02 · The same person, twice

Messy phone numbers and stray spaces

Phone numbers arrived in inconsistent formats, and one trailing space in a name silently split a customer into two. I normalize before comparing: digits only for phones, trimmed and lowercased for names, so the match key is stable no matter how the data was typed.

Normalize before you comparesync.js
function standardizePhone(phone) {
  if (!phone) return '';
  return phone.replace(/\D/g, '');   // digits only
}

const cleanName = name.trim().toLowerCase();
const cacheKey = `${cleanName}_${standardizePhone(phone)}`;

Problem 03 · It runs on live shop data

A dry run before anything is touched

This writes to a real shop’s records, so a mistake is expensive. I built a read-only mode that simulates the entire flow, creating nothing and archiving nothing, using its own cache so multi-repair matching still behaves. Safe to run against live data before committing to changes. The daemon also isolates errors per record, so one bad row never stops the loop.

Read-only simulationsync.js
const isDryRun = process.argv.includes('--dry-run');

if (isDryRun) {
  console.log(`[Dry-Run] Would create profile for "${name}"`);
  return;   // nothing is written, edited, or archived
}

Node.js · Notion REST API over native https · no SDK, no framework, no build step

Runs anywhere

Built for a phone, not a desk.

No desktop, no dedicated system. The whole team opens it on a phone from anywhere, updates a repair in seconds, and every change is attributed. Shared through Notion, so accountability is built in.

Outcome

Live and in daily use is the real proof point here, not a percentage — nothing about the old process was ever timed, so there is no honest before/after number to show. What is verifiable: the system has run against real shop data since it shipped, without a single duplicate customer.

0

duplicate profiles

The live cache and phone-number matching keep every customer to one record.

27

repairs tracked

At the time of these screens, filed automatically since launch.

Built for Shree Hanuman Power Tools, a repair shop in Navsari. Live, in daily use, shared across the team.

Next project

Shree Hanuman Power Tools

UX Research & Design →

A WhatsApp-first storefront for a power tools dealer. Fourteen pages, brief to final screens.