If you run a freelance UX/UI design business, your week is likely punctuated by fractured feedback. A client drops a four-minute Loom video, follows it up with three disjointed Slack messages at 9:00 PM, and caps it off with an email thread containing phrases like "Can we make the header feel more dynamic?" and "The button on screen 3 looks broken."
Translating this unstructured chatter into structured, actionable Figma tasks normally takes between four and six hours per week. While commercial AI tools like ChatGPT or Claude can streamline this triage process, paste-ing unreleased product copy, client strategic roadmaps, or confidential user research into cloud-based LLMs often violates Non-Disclosure Agreements (NDAs). If a client discovers their proprietary workflow details were used to train or process through a public cloud endpoint, your contract—and reputation—are on the line.
The solution is a self-contained, privacy-first AI feedback triage system. By pairing Ollama (a local model runner that operates entirely offline on your computer) with the Notion API, you can construct a zero-data-leakage pipeline that ingests raw client comments, strips out subjective noise, and publishes precise design tickets directly into your Notion workspace.
Architecture Overview: Zero-Cloud Triage Pipeline
To ensure strict privacy compliance, no text from your client communications ever touches an external AI server. The entire natural language processing (NLP) workload runs on your local machine's hardware.
| Component | Tool / Layer | Data Privacy Status |
|---|---|---|
| Raw Data Ingestion | Manual paste or local sync to Notion | Encrypted in your private Notion database |
| Local Orchestrator | Lightweight Python script or local automation agent (e.g., n8n Desktop) | Runs on localhost |
| Intelligence Layer | Ollama running an open-weight model (e.g., llama3.2 or mistral) |
100% offline processing; zero network outbound packets |
| Task Destination | Notion Master Task Database via official API | Stored strictly within your private workspace |
Step 1: Setting Up Your Local Model Engine
Before connecting to Notion, you need an open-source model running locally on your hardware. Ollama provides an executable engine that turns open-weight models into local API endpoints.
- Download Ollama: Install the native application for macOS, Windows, or Linux.
- Select a Lightweight Model: For parsing, categorizing, and structuring text, a 7B to 8B parameter model strikes the right balance between speed and precision without requiring dedicated server infrastructure.
- Initialize the Model: Open your terminal and start your preferred model:
Once initialized, Ollama exposes a local REST API endpoint atollama run llama3.2http://localhost:11434.
Step 2: Building the Notion Feedback Database Schema
Create a dedicated database in Notion titled "Client Feedback Triage." This database serves as both the landing area for raw comments and the organized task board for your design sprints.
Add the following properties to your database schema:
- Feedback Text (Property type:
Text) — The raw comment copied from Slack, email, or video transcripts. - Source Channel (Property type:
Select) — Options: Slack, Email, Loom, Figma Comments. - Client / Project (Property type:
SelectorRelation) — Name of the client account. - Processed Status (Property type:
Checkbox) — Default: Unchecked. - Task Title (Property type:
Title) — Automated output: Concise, component-focused ticket title. - Category (Property type:
Select) — Automated output: Visual Bug, UX Revision, Content/Copy Change, Subjective Opinion. - Actionability Score (Property type:
Select) — Automated output: Actionable, Needs Clarification, Non-Actionable. - Component / Screen (Property type:
Text) — Automated output: The target UI element or frame name. - Figma Action Plan (Property type:
Text) — Automated output: Bulleted checklist for design execution.
Step 3: Deploying the Copy-Paste Triage System Prompt
The key to converting chaotic client commentary into clean design tasks lies in prompt engineering. Client feedback frequently mixes actionable UI requests ("the font size on the checkout button is unreadable") with subjective preference ("the page feels cold").
Your local model must separate concrete design work from feedback requiring client negotiation.
Save the following system prompt within your local orchestration script or local execution pipeline:
System Prompt: UX/UI Feedback Triage Specialist
You are an elite Lead Product Designer and Design Ops Specialist. Your job is to analyze unstructured client feedback, extract real intent, filter out subjective opinion, and translate the rest into clear, actionable design tasks for Figma execution.
Task Rules:
- Distinguish Fact vs. Subjective Opinion:
- If feedback says "I don't like blue," mark Actionability as
Needs Clarificationand suggest asking for brand guide references.- If feedback says "The contrast on the CTA button makes it hard to read," mark Category as
Visual Bugand Actionability asActionable.- Extract Screen Target: Identify specific page names, components, or user flows referenced (e.g., "Mobile Navbar", "Pricing Matrix").
- Categorize Accurately: Use exactly one of these labels:
Visual Bug,UX Revision,Content/Copy Change,Subjective Opinion.Output Format: Respond strictly with valid JSON using the following key structure:
{ "task_title": "Short verb-first ticket summary", "category": "Visual Bug | UX Revision | Content/Copy Change | Subjective Opinion", "actionability": "Actionable | Needs Clarification | Non-Actionable", "target_component": "Target screen or component name", "figma_action_plan": "1. Step one\n2. Step two\n3. Step three" }
Step 4: Orchestrating the Local-to-Notion Pipeline
To run this pipeline without cloud intermediaries, use a lightweight local Python script that queries your Notion database for unchecked rows, sends the raw text to your local Ollama endpoint, and updates the Notion row with the structured JSON output.
Example Python Integration Script
import requests
import json
# Configuration
NOTION_API_KEY = "secret_your_notion_integration_token"
DATABASE_ID = "your_notion_database_id"
OLLAMA_ENDPOINT = "http://localhost:11434/api/generate"
HEADERS = {
"Authorization": f"Bearer {NOTION_API_KEY}",
"Content-Type": "application/json",
"Notion-Version": "2022-06-28"
}
def get_unprocessed_feedback():
url = f"https://api.notion.com/v1/databases/{DATABASE_ID}/query"
payload = {
"filter": {
"property": "Processed Status",
"checkbox": {"equals": False}
}
}
response = requests.post(url, json=payload, headers=HEADERS)
return response.json().get("results", [])
def process_with_local_ai(raw_text):
prompt = f"""You are a design triage AI. Analyze this client feedback and format as JSON:
Feedback: "{raw_text}"
Return JSON key format: task_title, category, actionability, target_component, figma_action_plan."""
payload = {
"model": "llama3.2",
"prompt": prompt,
"stream": False,
"format": "json"
}
res = requests.post(OLLAMA_ENDPOINT, json=payload)
return json.loads(res.json()["response"])
def update_notion_page(page_id, data):
url = f"https://api.notion.com/v1/pages/{page_id}"
payload = {
"properties": {
"Processed Status": {"checkbox": True},
"Task Title": {"title": [{"text": {"content": data["task_title"]}}]},
"Category": {"select": {"name": data["category"]}},
"Actionability Score": {"select": {"name": data["actionability"]}},
"Component / Screen": {"rich_text": [{"text": {"content": data["target_component"]}}]},
"Figma Action Plan": {"rich_text": [{"text": {"content": data["figma_action_plan"]}}]}
}
}
requests.patch(url, json=payload, headers=HEADERS)
# Run pipeline execution
def run_triage():
items = get_unprocessed_feedback()
for item in items:
page_id = item["id"]
# Pull text from 'Feedback Text' property
properties = item.get("properties", {})
feedback_objs = properties.get("Feedback Text", {}).get("rich_text", [])
if feedback_objs:
raw_text = feedback_objs[0]["text"]["content"]
triage_result = process_with_local_ai(raw_text)
update_notion_page(page_id, triage_result)
if __name__ == "__main__":
run_triage()
Hardware Considerations & System Limitations
Running local AI models eliminates data privacy risks, but it introduces local hardware constraints you must manage effectively.
| Factor | Local Model Setup (Ollama) | Cloud API Setup (OpenAI/Claude) |
|---|---|---|
| Data Privacy | 100% Private (Data never leaves RAM) | Requires strict enterprise zero-data-retention agreements |
| Hardware Requirement | Requires 16GB+ Unified Memory (Apple Silicon) or dedicated VRAM | Runs on any device via web requests |
| Processing Speed | 10–30 tokens/sec depending on hardware | 50–100+ tokens/sec |
| Multimodal Vision Input | Requires explicit vision models (e.g., llava) which require higher VRAM |
Native across standard web APIs |
Handling Multimodal Feedback
Clients often send visual annotated feedback—such as screenshots with red circles drawn on top. Standard 7B/8B text models running locally cannot analyze visual pixel data natively unless you load a vision-capable local model like llava or llama3.2-vision.
Workaround: If operating on standard local hardware (e.g., base Apple Silicon with 16GB RAM), copy the transcript or auto-generated video captions from Loom/Slack into the text field rather than uploading raw screenshots. This allows lower-parameter local text models to perform task classification reliably without overheating your workstation.
Troubleshooting Common Pipeline Issues
- Issue: Model returns non-JSON extra conversation.
Fix: Explicitly pass the"format": "json"parameter in your API request payload to Ollama. Modern open-weight models strictly enforce structured JSON formatting when this flag is toggled. - Issue: Categorization mislabeling subjective comments as bugs.
Fix: Update the local system prompt to include positive/negative examples (few-shot prompting). Explicitly show the model one sample of "make it look modern" (Subjective Opinion) versus "the contrast is too low" (Visual Bug). - Issue: Notion API returns authorization errors.
Fix: Ensure you have explicitly shared your target "Client Feedback Triage" database page with your created Notion Integration via the database'sConnectionssettings menu.
Frequently Asked Questions
Does using the Notion API expose my client data to Notion AI?
No. Standard workspace data transferred via official Notion integration APIs is governed by Notion's primary data processing terms. Notion AI functions as an opt-in feature within the workspace UI and does not automatically scrape external API data payloads to train public models.
Can I run this entire setup without writing code?
Yes. You can run the n8n Desktop application on your computer. n8n Desktop operates entirely locally and includes native nodes for both Ollama and Notion. You can visually wire the trigger (New Notion Database Item) directly to the Ollama node and send the parsed result back to Notion without touching Python script code.
How long does it take a local 8B model to process a feedback batch?
On modern Apple Silicon (M1 Pro/M2/M3/M4 with at least 16GB memory) or a PC equipped with a mid-range dedicated GPU (6GB+ VRAM), processing a raw paragraph of client feedback into JSON takes between two and four seconds. Processing a batch of 20 comments takes under a minute.
Conclusion
Automating administrative overhead doesn't mean sacrificing client privacy. By moving your parsing and categorization layer out of cloud LLM providers and onto your local machine via Ollama, you convert fragmented feedback across Slack, email, and Loom into actionable Figma tasks within Notion—saving 4–6 hours every week while staying fully compliant with your non-disclosure agreements.
No comments:
Post a Comment