.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, and every build meant retyping hundreds of fields and reconciling translations manually. These weren’t simple forms either. They were used for compliance and traceability, so mistakes could affect the underlying data. I traced the bottleneck, proposed a fix, and built a Python compiler that takes a governed CSV and turns it into canonical JSON, pre-assembling the form editor in one pass. I then designed the admin flow and Forms UI around it so the team could spend more time reviewing and less time typing. Builds that used to take days now take under four hours, with the same team handling about twice 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 a core part of supply chain compliance. Some have only a handful of fields; others have more than 600, across five languages, with conditional logic, calculated scores, and strict audit requirements. Before this project, every form was assembled by hand. Specs came in as Word files, PDFs, slide decks, spreadsheets, and diagrams. Important information was often split across files or missing altogether. The team retyped labels, keys, options, and translations, then had to reconcile inconsistencies when logic changed or IDs drifted between versions. Because these forms feed compliance evidence and on-chain records, this wasn’t just a slow process. It also created a data integrity risk. We needed one reliable source of truth that could produce the same schema every time.
The bottleneck wasn’t really the form editor. It was everything that happened before the form reached it. Specs came in different formats with no shared structure, so each build effectively started from scratch. I proposed standardizing the handoff itself: one governed, machine-readable CSV with known headers and clear rules. Once the input became predictable, most of the repetitive assembly work could be automated and the team could focus on the parts that actually required judgment. I wrote the Python compiler from scratch, designed the two-path admin flow, and worked with engineering on the platform integration. Compiler: governed CSV → JSON, including deterministic keys, translations, logic mapping, and diagnostics. Flow: manual build for edge cases, upload for scale. Forms UI: Search, Download sample, Upload CSV, row statuses, and quick Edit / Download actions. The result was about 90% faster builds, roughly 2× throughput, no ID drift, and a much clearer audit trail.
Client
The main question was simple: what does a form spec need to contain for a machine to build it reliably? That became the governed CSV contract: one file with known headers, an approved list of field types, and explicit columns for conditions and translations. The compiler reads that CSV and validates each row against the allowlist. It generates deterministic JSON keys so IDs stay consistent between builds and languages, builds labels for all five languages, parses options, maps visibility logic, and produces two outputs: the JSON used by the UI and a corrected CSV for review and audit. Strict mode stops when it finds bad rows. Lenient mode skips them and reports the issue, which mattered because some client specs were incomplete and blocking the entire build wasn’t always practical.
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, and sometimes even hand-drawn diagrams. Forms ranged from 5 to 600+ fields across five or more languages, often with conditional logic. Required information might live in another file or be missing entirely. The team retyped labels, keys, options, and translations by hand. That meant a lot of manual work, IDs drifting between versions, and inconsistencies that often surfaced only during review.
Now the process starts from one governed CSV with known headers and clear rules. The compiler validates the field types, generates consistent keys, builds the translations, maps the conditional logic, and opens the editor with most of the form already assembled. Instead of spending hours retyping content, the team can focus on reviewing the form and fixing the parts that actually need attention.
I kept both paths intentionally. Manual build is still useful for unusual or one-off forms that don’t fit the standard structure. For larger or repeatable work, the team can upload the governed CSV, let the compiler validate and build it in about 1–3 minutes, and open the editor with the form already assembled. No need to retype everything.
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. What had been a manual, error-prone process that took days became a task the team could complete in under four hours without relying on me to assemble every form. More importantly, the work itself changed. The team spends less time copying fields and more time reviewing decisions. The governed CSV also became the standard handoff format at BanQu, carrying the form specification from client input through schema generation and into the audit trail.
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 because keys are generated consistently on every build. 70–85% of repetitive typing, including keys, options, and translations, is now pre-filled by the compiler. A machine-readable audit trail connects the original spec to the generated schema and 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)