PI Design Studio
PRODUCT DESIGN
WEB APP
AI
Role
UX Design, Workflow design,
UI Redesign, User testing
Impact
60% Faster Rule Creation,
70% increase in user confidence,
and Scalable Design
Team
1 Designer, 2 Project Managers,
6 Developers , 2 ML Engineer
Overview ✨
What is PI Design Studio
PI Design Studio is a powerful rules configuration platform designed as part of a larger initiative to streamline and automate decision making in data pipelines. At the heart of the platform lies a workspace called Fabrix, which supports both deterministic (user-defined) and non-deterministic (AI-driven) rules.
When data is ingested, it flows through these two rule paths, and the outputs are evaluated by a Meta Model that selects the most reliable result based on a confidence score. This architecture enables flexible and intelligent rule-based processing, ideal for complex data environments.
One example, endless possibilities
Pi Design Studio adapts to any domain, data type, or workflow. Automating specialty drug enrollment is just one use case.
Case Example - Automating Speciality Drug Enrollment
A major pharma client needed to digitize thousands of handwritten specialty drug enrollment forms.
Problem:
Each form type had unique fields, and configuring rules manually was slow and error-prone.
Clinics submitted handwritten and faxed enrollment forms with inconsistent fields.
Backend teams had to write custom logic for every new form — slow and error-prone.
Solution with PI Design Studio:
The backend team uploaded Excel sheets into Pi Design Studio.
Each row defined the field name, its validation logic, and the LLM/RAG query needed.
The system instantly converted these into reusable configurations.
How it Worked?
Pi Design Studio converted these configs into reusable rules.
Both deterministic (fixed rules) and non-deterministic (AI-driven) logic ran in parallel.
A Meta Model selected the most reliable output with confidence scoring.
Result
Without writing code, the team set up automation for all form variations in days instead of months.
Data extraction became accurate, auditable, and scalable across hundreds of variations.
Goal 🚀
The primary objective was to build and deliver MVP 2 of the Pi Design Studio, an enhanced, end to end rule management system that supports AI-driven automation, improves accuracy, and enables easy configurability for data teams.
Outcome
Fast Rule
Creation
High User
Confidence
Scalable By
Design
Before
After
60% Faster Rule Creation - Drag-and-drop workflows and reusable rule blocks made configuration far more efficient.
70% Higher User Confidence -Section-wise organization, AI-powered suggestions, and clear status indicators gave non-technical users more control.
Scalable Design - New design uses modular cards/sections with enough breathing room, new data fields or actions can be slotted in without redesigning the whole page.
Key UX Challenges
Problem : Error Prevention & Validation
Users configuring rules in Pi Design Studio face uncertainty without the ability to test their logic, misconfigurations aren’t caught until execution in the Precog backend. This creates inefficiencies, erodes confidence, and complicates error resolution especially when managing multiple cohorts.
Solution:
Introduced a sample upload and preview feature that delivers immediate feedback. Each cohort displays a mini-preview showing matched vs. unmatched records at the point of configuration with inline feedback for mismatches. This empowers users to identify and correct errors early boosting accuracy and trust without executing the full backend workflow.
Problem : Lack of clear grouping & Structure
In the earlier design, rules, data fields, and features appeared in flat or loosely separated sections. This made it difficult for users to quickly understand which rules belonged to which cohort, and how features were connected to data fields. The lack of visual hierarchy increased cognitive load and slowed configuration, especially for first-time users.
Solution:
The new design introduces clearly defined cards for each cohort/rule set, with dedicated sections for Features, Data, and Functions. This grouping reduces ambiguity, visually separates contexts, and enables users to scan, organize, and configure faster without losing track of where they are in the workflow.
Designing the Solution
Users creates a fabrix by uploading the datasource or by selecting the existing templates.
List and Grid View of the created fabrix with its respective status.
Upload Dummy Data or use external Database to validate the rules added instead of waiting for the misconfigurations caught until execution in the Precog Backend.
Other Features of PI Design Studio
Action Type Form Builder
Fabrix Canvas Builder
Manage Hierarchy
Action Type Form Builder
Challenge (Before)
Hardcoded configurations: Earlier, every action type (dropdown, input, string, number, etc.) was hardcoded directly into the database.
This made the system rigid each time a new action type or option was required, backend changes were needed.
Non-technical users couldn’t easily create or modify action types, which slowed down workflows and increased dependency on developers.
Solution (Now)
Form Builder UI: Instead of hardcoding, a dynamic form builder interface was introduced.
Users can now directly configure action types (Dropdown, Input, String, Number, etc.) from the UI.
This builder dynamically generates forms for Fabrix creation, pulling the structure directly from the configurations.
No database-level manual changes are required everything is driven by the UI and reflected instantly.
UX Impact
Flexibility: Users can easily add or modify action types without backend intervention.
Scalability: New use cases can be supported without code changes.
Efficiency: Reduced dependency on engineering, faster setup.
Clarity: The builder UI makes it more transparent what each action type does and how it is structured.
Designing the Solution
Users can create a new Fabrix by entering the Fabrix Type Name and Description. They can then add different Action Types (String, Number, Select) from the builder to customize the form fields. Once a Fabrix is created, it appears in the Recently Added panel on the right side. From here, users can Duplicate, Rename, or Delete a Fabrix, making it easier to manage and reuse templates.
When the Action Type is set to Select, users can customize the field options in the left panel. They can also configure dropdown dependency values to control how options change based on other selections.
Once users configure dropdown dependencies, they can also define the corresponding values for each dependency.
Manage Hirerachy
Challenge (Before)
Hierarchy CRUD was backend-only:
Adding, updating, or deleting tenant hierarchies (e.g., parent-child org structures) could only be done through backend scripts.
Users had no self-service option to organize or maintain hierarchy.
Migration was tied to hierarchy but also backend-driven, meaning both operations required engineering help.
Solution (Now)
Manage Hierarchy:
Introduced a dedicated UI for CRUD ( Create, Read, Update, Delete ) operations on tenant hierarchy.
Users can directly add or remove nodes, restructure hierarchy, and view tenant relationships.
Migration (in PI Design Studio):
Data migration between tenants was separated as a controlled function in PI Design Studio, not in Manage Hierarchy.
This ensures migrations are more intentional, validated, and guided compared to simple hierarchy CRUD.
UX Impact
Self-Service hierarchy management: Non-technical users can now manage org structures without backend reliance.
Clarity & Separation of concerns for managing hierarchy and migrating data to different tenants
Reduced dependency on engineering: Faster changes, fewer backend tickets.
Safer Operations: Guardrails and UI-driven validation minimize errors in both CRUD and migration workflows.
Designing the Solution
Allows users to create and maintain organizational hierarchies for multiple tenants. It provides a simple interface to perform CRUD (Create, Read, Update, Delete) operations on hierarchy structures within a tenant.
When hovering over a Parent or Organization node, users can add new nodes under it, making hierarchy management more intuitive and interactive.
Future Enhancements
Canvas Playground
The current design provides a structured form-based approach to configuring Fabrix, ensuring accuracy and validation. However, as the complexity grows, scalability and readability become challenging. To address this, the future vision introduces a Playground Canvas a visual workflow builder that enhances clarity, reduces cognitive load, and makes complex rule logic more intuitive.
Moves towards a visual node-based editor where users can build workflows like a canvas.
Components (data node, deterministic/non-deterministic models, meta models, output nodes) can be dragged and connected visually.
Gives a bird’s-eye view of the workflow, making it easier to scale, debug, and manage complex Fabrix designs.
Enhances scalability (handling large numbers of rules/models) and collaboration (easier to understand at a glance)
My Learnings 🏆
Learned how to simplify complex workflows into clear, intuitive UIs.
Gained experience in designing for enterprise ecosystems.
Designed flexible yet constrained inputs to avoid overwhelming business users while still giving them customization power.
Iterated on design through continuous feedback, which helped me balance technical feasibility with usability.
Made with Love, Framer,
and a lot of Ctrl+Z