Project RELAY
THE <72-HOUR AI BUILD WORKFLOW
Role: Product Architect & Solo Builder
Timeframe: < 72 Hours (Concept → Production)
Stack: Lovable (React), Supabase, OpenAI Whisper, Gemini
Status: Live v1.0
THE BUSINESS PROBLEM: LOGIC DEBT
Most internal tools and zero-to-one products fail for the exact same reason: teams prioritize Fidelity (pixel-perfect UI) over Validity (solving the core operational friction). They spend weeks in Figma designing beautiful forms that users ultimately refuse to fill out because the data entry process itself is stressful.
This creates Logic Debt—spending expensive engineering cycles to ship flawless software that solves the wrong problem.
THE ZERO-HANDOFF MANDATE
For Project RELAY, I inverted the traditional design workflow. Operating as a Solo Product Architect, the mandate was to architect, validate, and deploy a live AI-driven React application in under 72 hours—completely bypassing the traditional design-to-engineering handoff to achieve maximum execution velocity.
01/ The Architecture: The "Galvanic Isolator"
In high-entropy environments (whether a fast-paced startup or a chaotic household), task coordination fails because data entry is wrapped in "High Voltage" emotion (stress, urgency, frustration). Traditional UX attempts to solve this by making forms look nicer. This is a fundamental failure of systems design. You cannot fix a corrupted input signal by changing the color of a UI button.
I architected RELAY to act as a digital isolator. In electronics, a galvanic isolator allows a signal to pass between two circuits while blocking direct electrical contact, preventing high voltage from frying low-voltage components.
In this application, the primary interface is unstructured voice input. A custom AI middleware layer acts as the Entropy Filter—stripping emotional adjectives, calculating a "Cognitive Load Score" (1-5), and passing a clean, sanitized JSON object to a rigid Supabase backend.
02/ The Logic-First Build Protocol
To bypass the traditional Design → Engineering handoff, I built the logic layer before scaffolding the UI. In standard workflows, teams design a beautiful interface and then pass it to engineering, who inevitably discover the form validation or backend routing is fundamentally broken.
By writing the System Prompt explicitly before touching the frontend, I validated the business logic in the AI middleware. This completely removed the need for complex backend filtering, state management overhead, or fragile frontend form validation. The UI simply renders what the logic layer dictates.
This is the exact prompt architecture deployed to the LLM node:
You are the 'Isolator' for the RELAY management system. You act as an Entropy Filter. You will receive a raw, unstructured, potentially high-emotion voice transcript.
1. EXTRACT: Identify distinct tasks from the noise.
2. NORMALIZE: Rewrite them to be neutral, short, and imperative. [!] STRIP ALL ADJECTIVES AND EMOTION.
3. WEIGH: Assign a 'Cognitive Load Score' (1-5) based on task friction.
4. ROUTE: Suggest an owner based on context cues.
Return ONLY a clean JSON object matching the Supabase `tasks` schema. No markdown formatting. No conversational filler.
03/ Visualizing Data Constraints: The Voltage Meter
Because the logic and data structures were heavily defined upfront in the PRD, the UI execution required zero guesswork. Using Lovable, I scaffolded the React interface using an "Industrial Schematic" design constraint: Deep Navy (#0f172a), Safety Orange (#f97316), and monospace data variables.
The critical UI component is the Voltage Meter (Load Balance). Instead of just listing tasks, the UI calculates the sum of the load_score integer across the database and displays a stacked distribution bar. This visualizes the invisible labor distribution across users, neutralizing operational resentment by proving the system is balanced via hard data.
04/ The 72-Hour Engineering Breakdown
To achieve this execution velocity, the 72-hour window was strictly compartmentalized. Because the PRD and logic were validated in Phase 1, the actual frontend scaffolding was trivialized.
Day 1 / The Circuit: Initialized the Lovable React environment using the "Deep Navy Schematic" design constraints. Configured the Supabase schema and integrated the OpenAI Whisper API for raw signal injection.
Day 2 / The Relay: Implemented the System Prompt middleware. Validated the Voice → JSON → Database pipeline to ensure 100% adherence to the strict data structure without frontend breaks.
Day 3 / The Interface: Polished the Kanban/List UI, implemented the Voltage Meter math logic, and deployed v1.0 to production.
This project serves as a live proof-of-concept for the Systems Architecture approach. By inverting the process—spending 60% of the time on Architecture/Logic and only 40% on the Build—I achieved an execution velocity that is impossible in traditional UX workflows.