Revionics
No-code workflow builder for retail pricing — before agentic AI.
Enterprise,B2B, SaaS
Product Design
Role
Senior Product Designer
Timeline
Q3 2022 – Q4 2023
team
4 senior designers, UX research team, PM, Engineering leads
platform
Web
The Context
Revionics is an enterprise AI platform used by retailers like Ahold Delhaize, Leroy Merlin, and Family Dollar to optimise pricing, promotions, and markdowns at scale. To put that in real numbers: a typical customer runs over 100,000 SKUs across thousands of stores, and the platform fires up hundreds of thousands of ML models in the background to generate price recommendations. (Source: Google Cloud Blog, 2023)
I joined a team that wasn't brought in for a UI refresh. The mandate was broader: rethink the platform, propose new product directions, and find ways to make it more competitive in a market that was starting to commoditise. I worked across several modules during my time on the project — vehicle management, funding management, design system, shortcut framework. The one I'm proudest of is the Automation Engine — a no-code, visual workflow builder I led from the first concept conversation through research and into the final design.
It's Friday. Gloria needs to get the weekly pricing performance recap to her buying team before end of day. She opens SAP. Exports a raw data table. Pastes it into Excel. Cleans the columns by hand. Cross-references against last week's file. Writes a summary email. Attaches the file. Sends it to six people. Two of them will reply within the hour asking for a slightly different cut of the same data. The whole thing takes around 90 minutes. Every week. It isn't her job. It's the overhead that sits between her and her actual job. The same pattern repeated across markdown alerts, supply chain notifications, approval requests. Every event needed a human in the loop. Not because the decisions were complex, but because the system had no way of acting on its own.
The Problem
We worked closely with the UX research team on this one. Direct interviews. Contextual observation. Persona validation sessions. And the same pain kept showing up regardless of who we talked to. Four validated personas. One shared frustration.
Emilia, 28 — Allocator. "Last-minute ad-hoc requests, outdated systems, delays in reporting. I just want a tool that does it without me exporting to Excel every time."
Gloria, 39 — Planner. "Inefficient reporting, unreliable systems, too much manual data work. I'm trying to plan inventory levels properly, but the tools work against me."
Nora, 35 — Buyer. "Too many people need to sign off on my decisions. By the time approvals land, the market has already moved on."
Jayden, 33 — Merchandise Manager. "Cross-team dependencies cause delays. I sit at the centre of the org but I'm always waiting on someone else."
What all four had in common: heavy reliance on Excel for things the platform should handle on its own, manual repetitive workflows with no scheduling or automation, approval bottlenecks that slowed down time-sensitive decisions, and no way to react to events without a human at every step. The opportunity was obvious: what if the platform could just do this for them?
Finding the Fix
Before drawing anything, I pulled the team into a workshop. The goal was simple but important: agree on what "automation" actually means in this context. The word means very different things to a designer, a PM, and a retail planner. If we didn't define it together, we'd build the wrong thing.
We mapped automation across five dimensions: the autonomy spectrum (from Laser to Johnny 5), the execution chain (Aware → Suggest → Do), task complexity (Grunt Work to Magic), visibility (Stealth Box to Open Box), and business outcomes from better decisions through to revenue. From there we evaluated three directions and landed on what we called Decentralised Magic — a flexible, visual, composable workflow builder. Research kept pointing the same way. People didn't just want automation. They wanted control. They'd been burned by black-box systems before, and they needed to see, build, and own their own workflows.
For competitive benchmarking I looked at macOS Shortcuts, Zapier, n8n, and node-based video editors like DaVinci Resolve. The pattern was clear: visual node builders feel powerful but approachable because the logic lives out in space. There's no code, but there's real programmability — enough flexibility to feel powerful, without the intimidation of a developer tool. This was late 2023. Agentic AI workflows weren't yet an industry conversation. The inspiration came from consumer software, and I had a hunch the mental model could carry over into enterprise.
Research and discovery
Sketches on paper first. Then lo-fi wireframes. Then a high-fidelity Figma prototype. Then real respondents. The first sketch already had the bones of the final product: Start → Create File → Send to Email → Monthly Approval → Final Step. The prototype covered the full flow end-to-end and went straight into validation sessions, with findings folded back into design within the same sprint.
Three things changed in testing. The component panel felt detached — early versions had it as a floating sidebar, users kept looking in the wrong place, we pinned it to a fixed right rail. Linear flows felt limiting too early — planners immediately asked "but what if the condition isn't met?", so conditional branching went in earlier than planned. And node configuration was overwhelming — early panels exposed every field at once, users said "too many options", we rebuilt it around progressive disclosure with core fields visible by default.
The solution landed as a visual workflow builder with three layers. A central Automation Library where users manage everything — their own, shared, and template-based — in card or list view, each surfacing status, flow count, and type at a glance. Creating something new felt like an extension of managing what already existed, not a separate mode you had to mentally switch into. The Workflow Builder itself — a vertical node canvas where users drag components and stack them into a flow. Logic nodes handle conditional branching. Action nodes do the work: Approve, Notify, Reforecast, Send Messages, Create File. No explicit connectors needed — the spatial layout carries the logic. And the Node Configurator — click any node and a context panel opens with its specific settings. A condition like "If date: start Saturday at 00:00 AM — next Friday at 11:59PM, AND status: Approved" reads like a business rule, not code. People shouldn't have to translate their work into a different language to automate it.
The Solution
The manual reporting workflow that took Gloria 90 minutes every Friday got replaced by an automation that runs at 8am without anyone touching it. Across the four persona types, the biggest shift wasn't time — it was cognitive load. People stopped keeping mental lists of things they had to remember to do.
To give a sense of the scale: a typical weekly reporting flow involved roughly 7–9 manual steps — export, clean, filter, cross-reference, write, attach, send, follow up on approvals. With the Automation Engine, the same workflow gets configured once in 4–6 nodes and runs on a schedule. For teams running multiple recurring processes a week, the time saving is significant. More importantly, it removes the cognitive load of remembering to do them at all.
The feature went through multiple rounds of user testing before shipping. Reception was positive across all four persona types. The prototype was presented to investors and received strong feedback as a product differentiator. The client extended the engagement by one year. The feature shipped, continued to evolve after my departure, and the design system I helped build is still active in the team's workflow. But the response that stuck with me most was simpler than any metric: "I didn't know we could do this. Why didn't we have this before?" Zero requests to go back to the old way of working — which felt like the real measure of success.
Who | The pain | What changed |
|---|---|---|
Emilia | Reporting delays, Excel exports every week | "Create File → Send Email" runs on schedule |
Nora | Too many approvals, market moves while waiting | Approve node auto-routes status changes |
Gloria | Manual weekly recap, unreliable systems | Scheduled automation fires every Friday at 8am |
Jayden | Cross-team dependencies cause delays | Notify node fires the moment a condition is met |
Reflection
The first version of the workflow builder used a purely vertical linear chain. In later iterations I started bringing in conditional branching — the If/Else and Branch nodes that let flows split based on business rules. If I were doing this from scratch today, I'd map the full complexity of enterprise conditional logic earlier. The moment users get comfortable with linear flows, they immediately want branching. That was foreseeable, and I should have planned for it sooner. The configurator went through a similar arc — early versions exposed too much at once. Configuration depth is valuable, but it should be progressive. Show the essentials first. Let the rest reveal itself when it's needed.
The bigger thing I took from this project is about enterprise users in general. They're not less sophisticated than consumer users. They're operating under different constraints. They don't need simpler tools. They need trustworthy ones. Visibility, predictability, and undo-ability matter more than delight effects. Most automation tools assume people want maximum autonomy. In practice, they want control with assistance — a system that does the work but lets them see the logic and own it.
One thing I'm genuinely proud of is the timing. I built this in late 2023, drawing inspiration from macOS Shortcuts and node-based video editors. Not from AI agent frameworks, which weren't really a thing yet. When the agentic AI wave hit in 2024–2025 and "workflow automation" became one of the defining design problems of the era, I'd already shipped a version of it in production. That wasn't luck. It came from looking sideways at adjacent domains and asking what enterprise software could learn from consumer software.