Empowering banks to configure complex logic—without code
At ODX360 (later LinearFT), engineering was responsible for building custom logic for every bank partner—a model that didn’t scale. I led the design of a visual workflow builder that enabled non-technical bank administrators to configure platform logic independently, reducing operational overhead while supporting future growth.
This project was more complex so I took on an IC role instead of my usual management role.
Context
ODX360 was a white-labeled B2B2C SaaS platform helping financial institutions digitize the customer journey from application to account management. The company was a pre-seed startup with ~30 employees and later merged with Fundation to form LinearFT in Q1 2021.
Problem
ODX relied on engineering to build custom logic for every bank partner, creating high costs, slow turnaround, and repeated back-and-forth on requirements. As bank needs evolved, this model didn’t scale.
Solution
We designed and built a visual workflow builder that allowed non-technical bank administrators to configure custom logic themselves—reducing engineering dependency while remaining flexible enough to support future platform growth.
Outcomes
Upon MVP launch…
🙌 100% of internal implementation managers using this can build a simple policy
📉 Reduced time spent by ~half for developers in customizing platform environments for bank partners
🔀 6/8 of existing clients’ policies can be visualized
🤑 Anecdotally, most differentiated feature presented when pitching to prospects
Understanding The Existing Platform
The ODX (later Linear) platform was built as a set of modular tools, each supporting a different part of the customer journey.
The policy editor lived within Admin Tools, where bank administrators managed and customized their platform instance.
The platform’s logic followed a simple hierarchy: Policy → Rule Set → Rule. Each layer was configurable, with child rules inheriting logic from their parent.
This logic was visualized directly in the analyst’s workspace. Before this feature existed, every rule had to be hard-coded by ODX engineers—making customization slow, expensive, and difficult to scale.
The opportunity
Enable banks to configure and manage their own policies through self-service—reducing engineering dependency while supporting platform growth.
Pain Points
1️⃣ Not built for scale
Every client required unique policy logic, ranging from simple to highly complex.
2️⃣ Delivery bottleneck
Engineering owned all policy setup and maintenance, creating a growing scalability bottleneck.
3️⃣ Expensive to retain customers
Clients relied heavily on ODX for ongoing changes, requiring constant back-and-forth.
Potential Wins
💰 For the business
Reduce reliance on the engineering team for client customization
Shorten policy setup and maintenance from months to days
Stay competitive with other configurable workflow platforms
👫 For users
Gain independence from ODX as a vendor
Create, test, and maintain bank-specific policies
Configure logic without writing code
To inform the solution, I evaluated direct competitors and existing workflow-building tools to identify best practices and gaps.
🚀 Product Strategy
Build a self-serve, no-code policy editor that prioritizes usability and safety—reducing engineering dependency while enabling banks to configure complex logic without documentation.
Defining Success
Design principles
🛠️ Usability over reuse
Leverage the design system, but never at the cost of clarity.
🛑 Design for failure
Assume users will break things; build in safeguards.
🧠 No documentation required
The product should teach itself - prioritize onboarding mechanics and workflows
Success Criteria
All internal implementation managers can build a simple policy end-to-end
≥50% of existing client policies can be visualized without logic changes (MVP)
Validate concepts through at least one usability study
Gathering MVP Requirements
The policy editor consisted of two tightly connected areas: These spaces worked in tandem, allowing users to create, update, and manage policies simultaneously.
Policy, Task & Document Library — where existing policies and assets were managed
Policy Editor — where new policies were created and edited
Design, product, and engineering collaborated to define MVP requirements for a self-serve customization experience.
Bank partners needed clear visibility into pass/fail criteria, with failed or indeterminate outcomes automatically generating tasks for manual review—ensuring applications could continue through the workflow.All internal implementation managers can build a simple policy end-to-end
The first iteration was straightforward and easy to use - but still felt really heavy.
Designing a Simple Workflow
I started by designing a simple four-step workflow using familiar form elements (dropdowns, inputs, checkboxes).
Early wireframes resonated with internal stakeholders, allowing me to quickly move into higher fidelity using the existing design system.
As requirements evolved, it became clear that users needed to visualize more complex logic and variable dependencies, which led to exploring a lightweight drag-and-drop interaction model—balancing power with approachability.
Concept Validation
To validate the experience beyond internal assumptions, I ran moderated usability testing with external users.
Method
Five 1-hour moderated sessions
Bank system admins and business analysts using enterprise B2B software
Clickable prototype over Zoom
Goals
Validate understanding of policies and rule logic
Test rule creation from scratch
Evaluate the end-to-end rule editor flow
What was tested
Basic workflow comprehension
Empty states, hierarchy, and instructional copyPolicy → Rule Set → Rule relationships
Information architecture and page layoutTask creation and interaction
Form validation and drag-and-drop behavior
🏆 80% of users successfully created a simple policy end to end
Users consistently praised the visual clarity and ease of use
All participants felt confident teaching the tool to teammates with minimal support
👎 However, several gaps remained that would have limited real-world impact if left unaddressed
Addressing FEature and Usability Gaps
Clearer Onboarding Patterns
We used empty states, descriptive CTAs, and familiar interaction patterns to flatten the learning curve—important for an enterprise feature users expected to be complex.
Full-Page Editing
Editing policies carried significant downstream impact, so we introduced a dedicated Edit Mode with strong validation—ensuring changes were intentional and reducing accidental errors.
Multi-Level Library Structure
Policies existed across multiple levels. We organized content using familiar card and table patterns, with tabs allowing quick lateral movement between the Rule, Task, and Document libraries.
Task Creation & Management
Tasks could be created within the rule workflow or independently, depending on role. These tasks were core to the system: rule outcomes automatically generated actionable follow-ups.
Policy Testing
Before publishing, users could test policies using real application data or mock inputs. The system ran the logic and surfaced different outcome scenarios, helping users validate accuracy with confidence.
A Strategic Pivot: From Guided UX to Scalable System Design
In Q1 2021, ODX merged with Fundation to become LinearFT, triggering both a visual rebrand and a significant expansion in product scope
Design Strategy Shift
The initial user base narrowed to more technical users for early rollout. This shift fundamentally changed our design constraints.
1️⃣ Policies became more complex and interdependent
2️⃣ Users were more technical and wanted speed over hand-holding
3️⃣ The platform expanded from SMB-focused banking products to product-agnostic financial workflows
The original policy editor—designed to feel safe and guided—began to feel heavy, rigid, and limiting. It wouldn’t scale with the new complexity or expectations.
I revisited the problem and reimagined the policy editor as a flexible, visual workspace—inspired more by tools like Figma than traditional enterprise admin panels.
Introducing the Linear Policy Editor
A fully flexible, visual system for creating, managing, and testing complex policies—built to scale with both product complexity and user expertise.
Progressive onboarding
Users could start immediately, learning the system through interaction rather than relying on account managers or documentation.
Flexible workspace
A boundless canvas allowed users to drag, drop, resize, and connect components—supporting policies of any size or complexity.
Technical query language (fast follow)
For advanced users, policies could also be viewed and edited as code—enabling quick edits, copy/paste duplication, and precise control over complex logic.
Visual policy creation
Users pulled elements from a library and connected them directly on the canvas, making logic and dependencies explicit.
Continuous validation & testing
Errors were always visible. Users could test policies with mock or real data before publishing, reducing risk and preventing accidental overrides. The system was designed to later support approvals as permissioning matured.
The pivot transformed the editor from a guided, form-based tool into a scalable policy-building system—modern, powerful, and aligned with the evolving needs of Linear’s customers.
V1 of the policy editor launched in Q1 2021. Upon launch…