AgencyHub
A two-sided marketplace where agencies buy white-label services from vetted providers. This version of the case study walks through how I actually work: the questions I ask, the order I ask them in, and the artifacts each one produced.
- Role
- UX/UI Designer
- Timeline
- 2020 - 2024
- Scope
- Marketplace, checkout, orders, provider tools
The Challenge
Agencies grow by saying yes — and every yes is a risk they absorb alone.
Digital agencies grow by saying yes. When a client asks for SEO and the agency only does ads, the agency either hires, refuses, or finds a white-label partner. Most choose partners, and most find them by trial and error. Every failed partnership costs money twice: the wasted spend, and the client who leaves.
AgencyHub's bet was that vetting could be a platform feature instead of a private struggle. For that to work, the product had to serve two sides with opposite needs: providers want to list fast, agencies want to trust what they find.
Trust is the product
The entire value proposition is that agencies stop vetting vendors themselves. Every catalog and listing decision had to defend that promise, even at the cost of growth.
Three parties, one transaction
Payment can come from someone who isn't the buyer and never logs in. Orders, notifications, and checkout all inherit that complexity.
One designer, four surfaces
Marketplace, cart, orders, and provider tools had to ship together, which made a shared component system a necessity, not a preference.
Why — what problem are we solving?
Before drawing anything: does this product deserve to exist?
Every project starts with the same discipline: write the problem down until it stops being vague. If the problem statement can't name who loses money and why, the design that follows is decoration.
Who — who are we designing for?
Two users with opposite incentives, and a third party who never logs in.
Personas here weren't a formality. The agency owner and the service provider want contradictory things from the same catalog — speed to list versus confidence in what's listed. Naming that tension early is what made the later trade-offs decidable.
Reframe — how might we make trust a feature?
Turning the challenge into questions the team could design against.
How Might We notes convert complaints into briefs. The useful ones aren't the obvious ones — 'HMW make vetting a platform feature' reframed trust from a support cost into the core product.
When & Where — where does the money actually move?
Mapping the journey exposed the flow nobody had scoped.
Walking both sides of the transaction end to end surfaced the design problem that shaped everything after: the agency buys, but its client often pays. The user flow made that detour visible before a single screen existed.
What — why isn't an existing marketplace enough?
Studying what exists before deciding what to build.
Lightning demos are cheap due diligence: an hour of looking at how Fiverr, Upwork, and vertical marketplaces solve listing, trust, and checkout — then being honest about why none of them fit a reseller triangle.
Solve — what's the fewest screens that support the work?
Paper first. Fidelity is earned, not assumed.
Fast sketches are where bad ideas get to die cheaply. Marketplace, cart, and checkout were sketched on paper, argued over, and only the survivors were rebuilt as high-fidelity wireframes.
The System
One system behind every surface.
Marketplace, cart, orders, and the provider's store were built from one set of components and layout rules. For a solo designer this wasn't aesthetic discipline; it was the only way to ship four coherent surfaces at once.
The same system absorbed the project's odd states, like orders waiting on a client and listings waiting on approval, without inventing new patterns for each.
How — how do we know it worked?
A design isn't finished when it ships. It's finished when it's measured.
The honest version: I moved on before the metrics matured, so this section makes no claims I can't back. Instead, it shows what shipped and the instrumentation plan I'd use to judge it.
The design made a new behavior possible: an agency can sell a service it doesn't deliver, with payment, requirements, and fulfillment handled by the platform instead of spreadsheets and email.
Vetting moved from a private, per-agency struggle to a platform feature. The approval gate is the product's trust claim, enforced by design.
Four surfaces shipped from one component system, by one designer.
What I'd measure next
If I continued this work, I would instrument the two riskiest decisions: how many checkouts end in a payment link, which shows whether the third-party flow is real demand, and how long provider approval takes, because trust is only a feature if it doesn't strangle supply.
The Framework
The questions I carry into every project.
This process isn't specific to AgencyHub. It's a question sequence I apply to any product problem — because a repeatable process is what makes design judgment transferable between projects.
Why
Understand the goal.
- What problem are we trying to solve?
- How does this product benefit customers?
- What business opportunity does it create?
Who
Define the audience.
- Which groups have significantly different motivations for using this?
- What are their pain points and emotions?
- What is their high-level motivation for solving the problem?
When & Where
Map the context of use.
- Where does the product meet the user's day?
- What has to be true right before and right after each interaction?
What
List and prioritize ideas.
- What could we build to fulfill the customer's needs?
- What already exists, and why isn't it enough?
- Which idea has the best effort-to-impact ratio?
Solve
Make it concrete.
- What tasks must the customer complete to succeed?
- What do four fast sketches teach before high fidelity?
How
Measure success.
- How would we know the solution worked?
- Which metric would expose the riskiest assumption first?
Next project
InstallPros