.png){kind=small}
ROLE/SERVICES
Product Design Lead ·
UX Engineering
LOCATION
USA 🇺🇸
YEAR
2024
Summary
Form builds at BanQu took 2–3 days. Specs arrived in five different formats. IDs drifted between languages. Every build meant retyping hundreds of fields, chasing clarifications, and reconciling translations by hand — for surveys that feed compliance evidence and on-chain audit trails. I traced the bottleneck, proposed the fix, and built it: a Python compiler that ingests a governed CSV and emits canonical JSON, pre-assembling the form editor in a single pass. Then I designed the admin flow and Forms UI that put it in front of the team — so their work shifted from typing to reviewing. Builds that took days now take under four hours. Same team, 2× the output.
SaaS Blockchain platform
The Challenge
Solution & Impact
Product Design Lead UX Engineering Python scripting React admin flow & Forms UI Self-initiated
Scope
BanQu forms are the backbone of supply chain compliance — surveys of 5–600+ fields across 5 languages, with conditional logic, computed scores, and strict auditability requirements. Before this project, every form was assembled by hand. Specs arrived as Word docs, PDFs, slide decks, and diagrams. Required columns lived in separate files or didn’t exist at all. Teams retyped labels, keys, and options — per field, per language — then chased clarifications when logic was inconsistent or IDs drifted between versions.
For a platform where these forms feed compliance evidence and on-chain records, the process wasn’t just slow. It was a data integrity risk.
We needed a governed, single source of truth that produced consistent, drift-free schemas.
The bottleneck wasn't the form editor — it was everything upstream of it. Specs came in five formats with no shared structure, so every build started from a blank slate. I proposed treating the hand-off itself as a product: a governed contract that every spec had to conform to. If a spec arrived in one machine-readable format, with known headers and clear rules, the assembly could be automated — and the team could spend its time on judgment instead of data entry. I wrote the Python from scratch, designed the dual-path admin flow, and worked with engineering to integrate the compiler into the platform. Compiler: governed CSV → JSON (deterministic keys, i18n, logic mapping, diagnostics). Flow: dual-path — manual for edge cases, automated for scale. Forms UI: top-bar Search / Download sample / Upload CSV, row statuses + inline Edit / Download. ~90% faster builds, 2× throughput, 0 ID drift, stronger data lineage for on-chain audit.
Client
The core question was: what’s the minimum a form spec needs to contain for a machine to build it reliably? The answer became the governed CSV contract — one file, known headers, a type allowlist, explicit columns for conditionals and i18n. Once the contract exists, everything else is compilation. The compiler ingests the CSV and validates every row against the allowlist. It generates deterministic JSON keys so IDs never drift between builds or languages. It localizes labels across all 5 languages, parses options, maps conditional visibility logic, and emits two artifacts: canonical JSON for the UI and a corrected CSV for audit. Strict mode fails on bad rows. Lenient mode skips and reports — because some clients had partially-formed specs and a hard block would have stopped launches entirely.
Gates unsupported field types against an allowlist. Requires an English title; flags or skips anything missing. Generates deterministic JSON keys. Builds locale labels across all 5 languages (i18n). Parses options; maps logic and visibility. Emits canonical JSON + a corrected CSV.
Python 3.x, csv / json stdlib
Governed type allowlist
Deterministic name builder
Dual outputs: JSON + corrected CSV
Diagnostics & skip reports
Specs arrived in mixed formats — Word, Slides, CSVs, PDFs, even hand-drawn diagrams. Forms ran 5–600+ fields across 5+ languages with conditionals. Required columns lived in separate files or were missing entirely. Teams retyped everything: labels, keys, options, translations. The result: weeks of manual work, ID drift across versions, and inconsistent logic that only surfaced during review.
One governed CSV. Known headers. Clear rules. The compiler validates types, generates deterministic keys, localizes across all 5 languages, maps conditionals, and opens the editor pre-built. Work shifts from typing to review. No more ID drift. No more reconciling translations by hand.
Two paths — by design. Manual build stays for edge cases and one-off forms that don’t fit a schema. The preferred path for scale: upload a governed CSV, the compiler validates and compiles in 1–3 minutes, and the editor opens pre-assembled. No retyping.
Fields configured one-by-one; repeated many times and per language.
.png)
Upload CSV → compiler validates/compiles → editor opens pre-built.
.png)
I wrote the Python, designed the flow, and shipped the UI. The compiler turned a manual, error-prone, days-long process into a 4-hour task the team can run without me — and it changed what their day looks like: from retyping fields to reviewing decisions. The governed CSV is now the standard hand-off format at BanQu, one file that carries the full spec from client to schema to on-chain record. The win wasn't the script. It was redrawing where the work happens — and who has to do it.
Search: find or filter large form libraries fast. Download sample: shows the governed CSV contract up front. Upload CSV: jumps straight to a compiled, pre-built editor. Status badges (Draft / Needs fixes / Compiled) for triage. Diff-able downloads: corrected CSV + canonical JSON. Shortcut actions: Edit / Download from the table.
Build time: 2–3 days → under 4 hours for a 100-field form (~90% faster). 2× throughput with the same team. ~60% less rework after standardization. 0 ID drift — every key is deterministic, every rebuild identical. 70–85% of typing (keys, options, i18n) now pre-filled by the compiler. Machine-readable audit trail from spec to schema to on-chain record.
Added search, filters, and CSV upload to cut navigation and pre-assemble builds.
.png)
NEW: Search – Global search across name/ID (debounced). Press / to focus.
NEW: Filtering – Quick filter next to search. Defaults: Status (Draft / Needs fixes / Compiled) and Owner (All / Mine). Selection persists while you browse.
NEW: Upload CSV – Top-bar action that opens the Form Uploader and returns you to the same search/filters.
Drag-and-drop CSV upload (or choose file).
“Download CSV sample” — shows the governed contract up front.
“See required headers” — quick link to the schema rules.
Compiler integration — validates, compiles, and opens the editor pre-built in a single pass (≈ 1–3 min).
CSV-only + size limit (e.g., up to 10 MB) for predictable performance.
.png)