Unlocking Private Equity for Shareholders
How I transformed a share registry into a secondary marketplace and turned a weeks-long manual process into a 30-second digital trade.
Information Architecture
Marketplace Logic
Product Strategy
Fintech Compliance
COMPANY
Liquidise
INDUSTRY
Fintech B2B
TIMELINE
Apr 2023 - Feb 2024 (launch)
ABOUT
Liquidise is a fintech marketplace built to unlock liquidity for private shares. I led the design transition from a static registry into a secondary market, connecting digital cap-tables to real-time trading.
CHALLENGE
Liquidise held $800M in locked assets with no way for shareholders to sell or for the business to earn revenue. I had to design an instant, regulated marketplace to replace a slow manual process and prove the platform's commercial viability.
TEAM
CEO & CTO (Founders), Head of Product, Product Manager, 5 Engineers, Product Designer (me)
IMPACT
I designed the instant trading experience behind the first automated secondary share trade by a private company in Australia. The Kester Black pilot moved 1,700 shareholders through a regulated marketplace with zero reported accidental trades, cut settlement from weeks to under 30 seconds, and was covered in the AFR.
Final prototype of the end-to-end trading journey
History
When Liquidise was Boulevard Global
The registry was accurate, well used and completely static. $800M sat inside it that no shareholder could use.
Liquidise started its journey as Boulevard Global, a share registry that managed private assets via distributed ledger technology. It served as the central source of truth for companies, moving share management away from manual spreadsheets into secure digital ledgers.
I joined in March 2022 as the only designer. For the first six months, I focused on scaling the registry to manage records for nearly:
170+
companies
10,000+
shareholders
$800M~
worth of shares
Boulevard turned spreadsheet cap-tables into secure digital ledgers
But that wealth was only on paper. Six months after I joined, my role shifted. My job was to figure out how to turn this static registry into a live marketplace.
Problems
Why the registry had to transform
We had two problems running at once: shareholders with no way to access their equity, and a business with no way to grow on top of it.
Within months of my joining, we hit a wall. While the platform was a successful database, it wasn’t a sustainable business.
User Problem
For our 10,000 shareholders, equity felt like a theoretical numbers game rather than real money.
1
Asset Rich, Cash Poor
Users could see their wealth on a screen but had no way to access it, often waiting years for an IPO. Like owning a house in a town with no property market.
2
Manual Nightmare
Selling shares required weeks of legal paperwork and high admin fees that often cost more than the sale itself.
3
No Price Discovery
Shareholders had no way to know what their shares were actually worth, leaving them with zero control.
Business Problem
The original registry model had reached its ceiling. Keeping records was no longer enough to keep the company solvent.
1
Revenue Stagnation
Subscription fees couldn't cover the high cost of customer acquisition.
2
Zero Transactions
We were missing our biggest revenue opportunity: transaction fees from the $800M sitting on our platform.
3
Survival Risk
With a shrinking cash runway, the business needed a fundamental shift to attract new investment.
Validation & Fundraising
A prototype disposed, but it secured the acquisition
Manual matching, partial fills, no guarantees. Enough to win the acquisition that funded the real build.
To grow beyond a static registry and attract investment, I built a POC that acted as a bridge to funding. I mapped the trading logic and designed the investor decks to show how we would move from spreadsheets to a digital marketplace.
The concept tested demand by collecting buy-bids before opening a sell window. Settlement was manual and not guaranteed, sometimes participants only received a partial match, but it proved the concept was viable.
The proof of concept. Manual matching, partial fills, no guarantee, and enough to win the acquisition.
This work was the main driver in securing the strategic investor who acquired the company. While the prototype was retired after the deal, it wasn't a waste of effort. It gave us what we needed to rebrand to Liquidise and the funding to double our engineering team to hit our new 12-month roadmap.
Secured Acquisition
The prototype and pitch decks were the catalysts for the investment.
Team Growth
The funding allowed us to scale from 2 to 5 Engineers.
12-Month Roadmap
Transitioned from survival mode to a fully funded, long-term product plan.
Mapping the Solution
Translating an AMM into something that moves real money
Guaranteed liquidity is a promise about how money moves, so before designing a single screen I had to map what needed to be true underneath it.
The POC proved demand but lacked instant, guaranteed settlement; it relied on matching buy-bids with sell-offers manually. To solve this, the founders looked to decentralised finance, specifically the Uniswap model of Automated Market Makers (AMM): an algorithm that prices trades from what is in the pool, instead of waiting for a buyer and a seller to agree on a price.
In plain terms: a shareholder opens the platform, sees a window is open on their company, offers some of their shares, sees the price the algorithm has set, and accepts it. The cash is in their account before they close the tab. Before this, the same outcome took weeks of legal paperwork, if it was possible at all.
Why a pre-funded pool instead of matching. Investor capital committed before the window opens, so the seller never waits for a counterparty to appear.
I led intensive workshops with the founders and the Head of Product to translate this high-level concept into a functional system. We had to figure out how to apply tokenisation to private equity while ensuring settlements were instant and guaranteed.
Two stages, because guaranteed liquidity needs a pool before it needs a market.
The 2-Stage Trading Journey
To ensure guaranteed liquidity, a two-stage approach was needed for secondary trading.
Build up the share pool
A window for shareholders to offer equity to seed the marketplace using fully funded cash pool for a guaranteed settlement.
Instant settlements (AMM)
Real-time trading powered by the AMM using the fully funded cash pool removing the need for manual matching.
I developed a Fund Flow Schema to map exactly how capital and equity moved across the platform. This diagram shows how shares and cash move between investors, the AMM pool, and the registry in real time.
This was critical because the AMM model introduced high financial complexity that required a clear blueprint before any code was written.
The Fund Flow Schema. Every state capital and equity can be in, and which system owns it at each step.
By visualising these flows, I aligned our technical, legal, and product teams on a single source of truth. This schema didn't just accelerate development; it became a core piece of our investor strategy, proving we had a scalable, compliant architecture for instant settlement.
Explorations
Building a window before trading starts
This was the first time users would act on their equity rather than simply look at it, which made it the hardest part of the product to get right.
To run the AMM, we first had to build a guaranteed pool of shares. I turned the "Build up share pool" step from our journey map into this functional flow to test the logic, which we called the Pre-trading window. This let us see how it actually felt for a user to move their equity into the system for the first time.
The Pre-trading window as a functional flow, before it was an interface.
With the UI kit and design system already in place, I wireframed straight away, reusing POC components. My strategy was an “Invisible Blockchain”: strip the technical jargon and focus on user trust and business value.
Wireframes reusing POC components. Speed over polish while the logic was still moving.
Invisible Blockchain in practice. AUD, no crypto jargon, nothing the user did not need to know.
Hiding the Tech
I used AUD and removed all crypto-jargon. I wanted the experience to feel like a simple familiar app.
Removing Uncertainty
I made prices and fees unmistakable. I had to ensure the core maths worked before adding complex UI layers.
Speed to Validation
I reused existing components to get a functional version in front of the founders for quick feedback.
Iterating through weekly feedback loops
I presented these flows in weekly sessions with the team, board, and investors to stress-test the logic. Their feedback helped move the design from abstract wireframes to a high-trust trading experience.
Providing context for high-stakes actions
Internal walkthroughs revealed that the interface was too opaque for such a high-stakes task. Without clear feedback, turning equity into cash felt uncertain. To fix this, I introduced information boxes to give users immediate context on their current state and clarify exactly what action was required next.
Information Boxes. Telling users what state they were in and what to do next.
One box per state, including the ones users hope never to see.
Eliminating redundant naming
Feedback showed that "Pre-trading" followed by "Trading" was repetitive and lacked a clear distinction. We explored several iterations, including Early selling window and Initial selling window, but the team agreed they still weren't clear enough. We eventually landed on Sell-auction to create a sharp, functional distinction between the initial pooling stage and the live market.
Pre-trading, Early selling, Initial selling, Sell-auction. Four rounds to find a name that explained itself.
Translating technical states into a clear journey
I mapped every stage an offer travels through, from the initial sell offer to the final settlement price. I translated these backend stages into a Timeline Stepper and a State-Aware UI. This ensured the user always knew where they stood in the transaction, removing the "black box" feel of the automated algorithm.
The Timeline Stepper. Stage as structure, not a status chip.
State-Aware UI. Every component below the stepper changes behaviour with the stage.
The Trading Window
I proposed a 90-second price lock. The AMM said no.
I proposed a 90-second price lock to give users certainty before committing. The maths behind the AMM made it impossible, so the design changed instead.
The Live Trading window was the core of Liquidise: manual, uncertain matching replaced by an automated marketplace.
The Live Trading window. Flows that had to survive a price moving underneath them.
Managing Visual Hierarchy
To prevent the UI from becoming overwhelming on the web, I introduced collapsible cards to the design system. This allowed the now closed Sell-auction details to tuck away, keeping the user’s focus entirely on the active trade and ensuring the execution interface remained above the fold. This created a natural progression from "sell-auction" to "trading", while ensuring the most critical actions were always visible without scrolling.
Collapsible cards keep the closed Sell-auction out of the way and the active trade above the fold.
Handling Constraints & Edge Cases
I had to account for high-stress edge cases, such as price shifts happening while a user was mid-decision.
However, a technical walkthrough of the AMM revealed that locking prices for that long would disrupt the liquidity pools and create significant financial risk for the platform.
The 90-second price lock. Rejected: holding a price that long would have destabilised the liquidity pools.
I pivoted to a Re-check on Accept model. The UI now verifies the price the millisecond a user hits "Accept." If the market moves, the interface catches it instantly, shows the update, and requires a fresh confirmation. This balanced user needs with the mathematical reality of the AMM.
Re-check on Accept. The price is verified the millisecond a user commits, and a moved market forces a fresh confirmation.
Additionally, because the share pool is unpredictable, I designed specific states for when insufficient shares were available to fulfil a requested trade amount. This turned a technical limitation into a clear user expectation, informing the user exactly why a trade might be partially filled or unavailable before they committed.
Insufficient shares, designed as an expectation rather than an error.
Every state a trade can be in. The five on the happy path took the least design time.
Designing Positive Friction
In a 30-second trading environment speed matters, but accidental trades are a legal nightmare. I introduced Positive Friction so every trade was a conscious, binding decision: “Decline” and “Accept” physically separated to prevent errors during high activity, and a mandatory checkbox before any transfer starts, forcing one last look at the final AUD price.
Positive friction. Separated buttons and a mandatory checkbox before real money moves.
Settlement & Compliance
Settlement in seconds, under an AFSL
Traditional bank transfers take days to clear. The wallet had to make settlement instant without loosening a single legal requirement.
I took this initiative from concept to execution in just two weeks, collaborating closely with a single engineer. By integrating the Monoova API, I created a system where funds could be verified in advance, ensuring that when a user clicked "Buy," the settlement happened the moment the trade was accepted.
Operating under an AFSL, the licence required to handle other people's money, meant the wallet had to handle rigorous legal requirements. I focused on weaving these into the user journey so they felt like security features rather than bureaucratic hurdles:
Identity verification
The wallet stays locked until identity is fully verified. Rather than treating this as a gate, I surfaced clear feedback on verification status so users understood exactly when and why they could start trading.Automated post-trade paperwork
The moment a trade executes, the system automatically updates the share registry, files forms with ASIC, Australia's corporate regulator, and issues legal certificates. I designed the UI to reflect this instantly, removing the administrative burden entirely from the user experience.Penny-drop verification
To ensure capital only moved to authorised accounts, we send $0.01 to the user's bank account before any high-stakes trades occur. A small speed bump that proved the system was secure before users committed larger sums.
Penny-drop verification. One cent proves the account is real before anything larger moves.
Guiding the User Beyond the Dashboard
Since these trading windows were time-sensitive and high-stakes, I designed email notifications to guide users through the journey.
I mapped email triggers to key milestones, the start of a Sell-auction, a final settlement, so users did not have to sit on the dashboard or risk missing a window. I treated these as digital receipts: written confirmation of trades, prices and settlements, a permanent record in the inbox that answered “what happened?” before anyone had to ask.
Emails as digital receipts. A permanent record of price, trade and settlement.
Implementation & QA
How a backend swap saved our launch without touching the UI
I designed the interface so it was never tied to the backend, which is why swapping Ethereum for Redbelly cost us nothing in UI work.
Engineering Efficiency through Design Systems
I leveraged the React MUI design system I had built from the ground up, so engineers spent their time on backend trading logic rather than building UI. New components went in only where a trading need was genuinely unique, which kept front-end debt flat as functionality scaled.
The Strategic Value of Backend-Agnostic Design
In a regulated startup environment, I knew we might need to pivot our underlying systems as the product evolved.
This decision proved critical during internal testing. We found that the original Ethereum-based setup was too slow for high-frequency trading, causing delays that would have frustrated users. Because the UI and logic were independent of the backend, we were able to switch the entire system to the Redbelly Network for faster processing with zero updates to the interface. This saved the team weeks of rework and kept our pilot launch on track.
The interface bound to trade states, not to the chain. Swapping the execution layer changed what produced a state, never what the state was.
None of this happened in isolation. The price lock died in a walkthrough with engineering. The naming went four rounds with the team. The AMM logic came out of workshops with the founders and the Head of Product. My job was to keep the design honest to the maths, the regulator and the 1,700 people who would actually use it.
What the team said
“He has the ability to take ideas from concept stage into mockups at speed. What sets Fawaz apart is his genuine ability to understand the needs of our users… He was responsible for designing and updating our app’s entire interface.”
Victoria Tran, Product Manager
“Fawaz is a flexible and talented designer with an eye for detail and an open nature as is required for startups. Working with him has been a breeze.”
Brendan Murty, Lead Software Engineer
Outcome
1,700 investors, zero accidental trades, $70,000 traded
The Kester Black pilot was the first time a private company in Australia completed secondary share trading through a fully automated marketplace.
It was the platform’s first live test. In under seven months, we moved from concept to a regulated digital marketplace, condensing a weeks-long manual settlement process into a sub-30-second automated experience.
Kester Black, a sustainable Australian beauty brand, had 1,700+ retail investors from a 2020 crowdfunding raise. By 2024, many shareholders sought liquidity for personal expenses like rising mortgages and school fees. Founder Anna Ross described managing these trades manually as "onerous and complex." Liquidise was designed to automate this administrative burden while ensuring regulatory compliance.
Zero Accidental Trades
1,700+ shareholders traded with zero reported accidental trades, which is what the Positive Friction patterns were there to prevent.
Regulatory Proof
An error-free run at scale gave regulators the proof of safety to validate the AMM model, de-risking future expansion.
Instant Settlement
Settlement went from weeks of legal and spreadsheet coordination to under 30 seconds, without loosening security.
Trust by Design
The wallet, Re-check on Accept and the notification trail together were what made people willing to commit real equity.
One defect did surface. Clicking Accept twice rendered the trade twice in the interface, though only one transaction ever executed and no money moved incorrectly. A display bug rather than a financial one, but ours, and internal testing had not caught it.
“Kester Black is the first private company to complete more than $70,000 of share trades on a new market for trading private companies.”
Australian Financial Review, “Equity traps in the growing pool of share schemes”
Kester Black entered voluntary administration in July 2024, seven months after the pilot. The shareholders who sold in that window got their money out, which is the clearest case I have for why the product needed to exist.
Reflection
What I learned
High-stakes fintech is not e-commerce. You aren’t just moving pixels; you’re moving life savings. During the Liquidise pilot, I managed the complexity of a new financial market by prioritising data transparency and regulatory integrity over traditional "frictionless" design.
1
Infrastructure-first design.
The worst UX problems lived in the backend, in bank delays and blockchain latency. Fixing them meant designing systems like the pre-funded wallet, not screens.
2
Resilience is a business strategy.
Decoupling the UI from the tech stack let us move from Ethereum to Redbelly with zero interface changes, saving weeks of rework and holding our launch date.
3
Compliance builds trust.
ASIC and AFSL requirements were design tools. Positive Friction turned a regulatory speed bump into a signal of safety.
4
Maths needs translating.
Turning AMM logic into something a shareholder could act on took a constant loop between founders, engineering and legal.
What I would do differently: everyone who tested it had built it.
We did not just click through flows. We ran the settlement path internally with real money, so funds genuinely moved before a shareholder ever touched it. What we could not simulate was someone who did not already know what was supposed to happen next. That is precisely the gap the double-click defect fell through: a user pressed Accept twice because they were not certain it had worked, and nobody who built the system would ever have done that. Next time I would put the flow in front of people with no context well before a live window, even informally.
Designing for Liquidise wasn't about making a "trading app", it was about designing a system of trust.
"Designing for Liquidise taught me that in high-stakes fintech, clarity is a security feature. By being transparent about how the auction and trading windows worked, I turned a confusing technical process into a reason for users to trust the platform."