Before
Freeform canvas
All nodes looked similar. Connections crossed. No clear start, middle, or end. Reading a flow meant tracing every connection from scratch.
Flow Builder,From Unusable to Independent
Merchants were supposed to build their own conversation logic. Instead, they were calling support every time they tried. The builder had all the power and none of the usability.
The problem in plain terms
The Flow Builder was the core of HelloRep. It was where merchants defined how the chatbot should behave,what to say when a customer asks about shipping, how to handle a refund request, what to do when someone wants a product recommendation. The logic lived in a canvas of connected nodes: triggers, conditions, actions, branches.
In theory, merchants could build anything. In practice, almost none of them could build anything without calling for help. The canvas was too freeform. There was no visual hierarchy between a trigger and an action. Branching logic became a tangle of connections after three or four steps. You couldn't tell at a glance what a flow did,you had to trace it node by node from the start.
The builder supported complexity,but it did not structure it. Understanding what a flow did required reading every node top to bottom.
The builder supported complexity,but it did not structure it. Understanding what a flow did required reading every node top to bottom.
Why it was confusing
The core issue wasn't the number of features,it was that all nodes looked the same. A trigger, an action, and a condition had nearly identical visual treatment. There was no spatial or typographic hierarchy that told you where a flow started, what the decision points were, and where things resolved. When flows grew past four or five nodes, connections stopped making spatial sense. And branching compounded everything,a flow that worked for one scenario became a nested mess when you added a second path.
Merchants weren't failing because they didn't understand automation. They were failing because the interface gave them no map of what they were building.
The redesign
The goal wasn't to simplify the logic,merchants genuinely needed what the builder could do. The goal was to make that logic readable. I redesigned the builder around a typed node system: every element has a clear role, and that role is visually encoded. Triggers are where flows begin. Conditions create explicit branches. Actions execute things. Goals close the flow. You always know what kind of node you're looking at and where it sits in the sequence.
After
Typed, hierarchical canvas
Each node type has a distinct visual identity. The flow reads left to right following the logic's natural sequence. Branches are visually contained and labelled.
The redesigned canvas. Node types are colour-coded and visually distinct. Branching logic is grouped and labelled. The overall structure reads left to right,evaluate intent, decide, act, resolve.
What changed for merchants
The most immediate change was that merchants could read their own flows. Before the redesign, a flow built two weeks ago required tracing it again from scratch. After, the visual structure carried enough information that scanning was enough. Onboarding a new team member to an existing flow went from a guided walkthrough to self-service.
Editing became safer too. The old canvas was easy to break,moving one node could silently disconnect a branch. The redesigned system made flows non-destructive by default: you could reorganise, add conditions, and swap actions without losing the connections you hadn't touched.
What it couldn't solve
The redesigned builder was significantly better,but it still required merchants to think in terms of logic. Some took to it naturally. Others still found it abstract even with the cleaner interface. That friction pointed toward something bigger: for most conversations, writing the logic explicitly was never the right mental model. That realisation became the seed for Test & Train.
The Flow Builder went from something merchants needed hand-holding to use, to something they could operate independently. That was the goal. And when AI improved enough to make explicit logic optional, the builder became a power-user tool rather than the onboarding hurdle it once was.