From Project Details to Checkout: Designing for a Talent & Project Marketplace
TL;DR: A Summary
Marketeq Projects is a remote talent marketplace for buying pre-scoped projects and services complete with curated deliverables and a fully assembled team. The objective of this sprint was to design a project details page that helped clients confidently evaluate and purchase projects. The page needed to go beyond a simple description, offering key details like assigned team members (even when some roles were unfilled), tools used, pricing, project type, and related work. The primary focus was on building trust and clarity to support informed decision-making and smooth progression through checkout.
Role
UX Designer & Researcher
What I worked on:
UX research, personas, user journeys, feature prioritization, scope breakdown UI, tooltip logic, and full wireframes with usability testing
TL;DR: A Summary
Marketeq Projects is a remote talent marketplace for buying pre-scoped projects and services complete with curated deliverables and a fully assembled team. The objective of this sprint was to design a project details page that helped clients confidently evaluate and purchase projects. The page needed to go beyond a simple description, offering key details like assigned team members (even when some roles were unfilled), tools used, pricing, project type, and related work. The primary focus was on building trust and clarity to support informed decision-making and smooth progression through checkout.
Role
UX Designer & Researcher
What I worked on:
UX research, personas, user journeys, feature prioritization, scope breakdown UI, tooltip logic, and full wireframes with usability testing
TL;DR: A Summary
Marketeq Projects is a remote talent marketplace for buying pre-scoped projects and services complete with curated deliverables and a fully assembled team. The objective of this sprint was to design a project details page that helped clients confidently evaluate and purchase projects. The page needed to go beyond a simple description, offering key details like assigned team members (even when some roles were unfilled), tools used, pricing, project type, and related work. The primary focus was on building trust and clarity to support informed decision-making and smooth progression through checkout.
Role
UX Designer & Researcher
What I worked on:
UX research, personas, user journeys, feature prioritization, scope breakdown UI, tooltip logic, and full wireframes with usability testing
Understanding the Problem Space
Pre-Launch Issues
The idea behind the Marketeq marketplace was simple:
Buy a scoped service project → Choose your team → Launch
The original version of the marketplace, however, lacked clarity and structure. During internal tests and early user flow reviews, we kept running into the same question: what exactly am I committing to here?
❌ Problem 1: Team Assembly Confusion
Inviting talent to a project sounds great — until you realize you don’t know:
How many people are needed
What roles are already filled
Who you’re actually hiring
There was no live status of open positions, and no reassurance that the project would still “work” if someone wasn’t invited right away.
❌ Problem 2: The Checkout Cliff
The CTA said “Start Project,” but most users weren’t ready to start. There was no preview, no summary, no sense of what happens next. No financing options. No buyer protection. No safety net. And when people aren’t sure… they don’t click.
“It kind of feels like I’m buying a flight without seeing the destination.”
— Internal test participant
👀 What We Noticed Early
We hadn’t launched yet, but user feedback was already telling us this wasn’t it. Even internal testers were stalling out, second-guessing their next step, or asking questions the UI didn’t answer.
That’s when we knew: Before launching, we needed to redesign the whole experience — not just visually, but emotionally.
👤 Personas
We spoke with early-stage users to understand what was really going on when they tried to launch a scoped project. Even though this was all pre-launch, their feedback hit like real usability testing. And it helped us figure out who we were designing for and what they actually needed.
👩💼 Megan — Ops Lead at a Digital Agency
“I just want to make sure I’m not missing anything.”
🧠 Goals
Launch a new client project without bottlenecks
Pick the right team without micromanaging
Make sure the client knows what they’re getting
😰 Frustrations
Worries that the deliverables don’t fully match what her client needs
Unsure who’s responsible for what
Nervous about clicking “Start” without a second pair of eyes
💡 What she needed:
A scope summary she could trust, a preview before committing, and clear team role visibility.
👩🏽🎨 Claudia — Freelance UX Designer
“Am I even part of this project yet?”
🧠 Goals
Get staffed quickly on solid projects
Avoid miscommunication with team leads
See what she’s expected to do before accepting an invite
😰 Frustrations
Didn’t know if she was confirmed or just “floating” on a team
No visibility into deadlines or scope when invited
Felt replaceable
💡 What she needed:
A transparent project layout, real-time invite status, and the ability to confirm her role before committing.
🧠 What We Took Away
Buyers wanted confidence.
Talent wanted clarity.
Everyone wanted to avoid surprises.
These personas shaped everything — from how we displayed deliverables and team roles, to what trust signals we prioritized at checkout.
🗺️ User Journey Map
We mapped out what it actually feels like to launch a project on Marketeq Projects — from browsing to checkout — and yeah… it got a little bumpy.
Even in a pre-launch state, the journey had a lot of emotional ups and downs. The biggest takeaway?
People weren’t just clicking buttons.
They were guessing. Stressing. Second-guessing.
And sometimes, they’d just give up.
💡 Where Things Got Messy
No overview before checkout
No visual on how many roles were still open
No payment breakdown or assurance of protection
No emotional reassurance that it was okay to hit “Start”
😰 What We Had to Fix
To create a better experience, we needed to:
Break down the scope into clearer, editable phases
Visualize team assembly in real-time (“Need 4, have 2”)
Show a transparent, reviewable summary before checkout
Add micro-reassurances like badges, refund policies, and tooltips
🔄 User Flows
On paper, the original user flows looked solid:
→ Browse project
→ Customize scope
→ Invite team
→ Checkout
→ Done.
But in practice? Users hit friction way earlier than expected. They’d stall. Loop back. Ask questions the UI didn’t answer. And worst of all — they weren’t sure if they were doing it “right.”
🔍 Original Flow Highlights (and where it broke down)
1. View Project → Read Scope → ?
“I don’t know what this includes... Is this everything I get?”
Deliverables were long, unstructured, and felt like reading a legal document.
Users wanted a clean, step-by-step preview — not a wall of tasks.
2. Invite Team → Confusion
“How many people do I have to invite? Can I do that later?”
There was no live status for how many team members were assigned vs. needed.
Clients weren’t sure if their project could proceed with just 1 or 2 people invited.
3. Checkout → Cold Feet
“Am I committing to something right now? What happens if I change my mind?”
No review screen.
No payment flexibility or trust reassurance until after the “Start Project” CTA.
This was the biggest drop-off point.
✍️ What We Re-Mapped
We redesigned the flow with emotional clarity in mind — not just usability.
New flow highlights:
✅ Scope Preview → Phased Deliverables → Clear Editing Logic
✅ Team Invite → Live Role Status (“Need 4, Have 2”) → Optional Invites
✅ Review Summary → Payment Plans + Refund Policy → Confirm & Start
Each flow now answers the question:
“Do I understand what’s happening — and do I feel okay moving forward?”
That became our North Star.
🧠 Affinity Map
We gathered notes from interviews, internal feedback sessions, and early usability tests — and then we sat with it all to find the patterns.
It turns out, a lot of users were asking the same questions.
Not always in the same words, but with the same energy:
“Wait, what am I supposed to do here?”
“Can I change this later?”
“Am I locked in if I click this?”
Once we clustered everything, it became obvious:
We weren’t just solving for navigation or layout.
We were solving for reassurance.
🔍 Common Themes We Found
💬 Trust + Transparency
“I need to know what I’m getting before I pay.”
“What happens if the project doesn’t go as planned?”
🧩 Scope Clarity
“This list of deliverables is overwhelming.”
“Which part is editable vs. fixed?”
“What happens if I delete something by accident?”
👥 Team Assembly Confusion
“How many people do I need to invite?”
“What if I don’t know anyone yet?”
“Can I finish checkout with just one person?”
💸 Checkout Hesitation
“Is there a way to split payments?”
“Where’s the final review screen?”
“Can I cancel if I mess something up?”
💡 What This Told Us
People didn’t want more options.
They wanted fewer unknowns.
So every feature from here on out — tooltips, trust badges, phased scope breakdowns, refund policies — was designed to answer one core question:
“Is it safe to move forward?”
Understanding the Competition
Identifying the Benchmark
something something explain how benchmark features were discovered and identified by analyzing what direct and indirect competitors included in their equivalent of a project details page. features were noted and listed before being card sorted to determine what was necessary to include, what would be nice to include, and what would not be included in the Marketeq design.
🔍 Competitive Analysis
Before finalizing any design decisions, we took a deep dive into other marketplaces — not just to “benchmark” them, but to really understand how they make users feel.
Spoiler: most of them were either confusing, cold, or trying to be clever instead of clear.
🛠️ Who We Looked At:
We analyzed a mix of direct and indirect competitors:
Upwork (freelancer-first, light on scope structure)
Fiverr (structured but rigid)
Themeforest (great spec breakdowns, product clarity)
Amazon, Etsy, Best Buy (e-commerce-level tooltips, trust layers, and purchase flow clarity)
Target, eBay, Epic Games (used for tooltip structure, “payment plan” transparency, and FAQs)
🔎 What We Were Looking For:
How clearly are deliverables communicated?
Can users preview exactly what they’re buying?
Is it easy to understand who’s behind the service/product?
Do users feel safe to check out?
✖ Where They Fell Short:
🧱 Upwork & Fiverr
Deliverables are often just a few bullet points or marketing fluff
Hard to customize or understand what changes actually do
No clear invite logic for multi-person teams
🧩 Themeforest
Good specs… but no people. Just assets.
No live team or service dynamics — not comparable, but worth stealing ideas from
💬 Amazon, Etsy, Best Buy
Surprisingly strong tooltip patterns
Clear policies, reviews, delivery estimates — but not designed for services
These gave us a model for how to explain complex scope info with simple overlays
💡 Takeaways We Brought Into Our Redesign:
✅ Use tooltips the way e-commerce uses shipping info
✅ Show deliverables in steps — not a wall of tasks
✅ Make payment breakdowns obvious (Klarna-style)
✅ Let users “meet” the creator and team, not just see the work
✅ Offer real trust signals upfront — not buried in policy pages
This helped us filter out what not to do — and focus on what would actually help our users feel more confident moving forward.
🎯 Define the Strategy
We didn’t need more features.
We needed the right ones — delivered in the right order — with zero guesswork.
So we zoomed out and asked:
What do clients actually need to feel confident clicking “Start Project”?
What’s non-negotiable for talent to feel safe accepting an invite?
And how do we build trust before commitment?
That’s how we defined the goals — and decided what belonged in the MVP.
🧠 Project Goals
For Clients:
Understand the project scope at a glance
Invite the right team with real-time clarity
Feel 100% confident before checking out
For Talent:
Know their role and expectations before accepting
Trust the project is legit and well-structured
Get clear visibility into who they’re working with
For the Business:
Reduce drop-off during team invite and checkout
Increase successful project starts
Build a scalable model that supports transparency and AI-assisted structure
🧱 MVP Feature Prioritization
We grouped feature ideas into Must-Haves, Nice-to-Haves, and Not Right Now — based on impact, effort, and user need.
✅ Must-Have
Editable phased deliverables
“Live Team Status” (e.g. Need 4, Have 2)
Trust badges and agency bios
Tooltips explaining scope, roles, and payment
Klarna-style financing breakdown
Purchase protection and refund policies
🤔 Nice-to-Have (Later)
Secret “auto-match” team mode
Creator DM feature
Real-time invite acceptance status updates
Version history for scope edits
❌ Not Right Now
Build-your-own-scope from scratch
Project-based chat integrations (Slack, Discord)
Multi-project bulk checkout
Everything we prioritized came back to one question:
“Does this reduce doubt at the moment someone’s about to commit?”
If it didn’t… it didn’t make the cut.
🎨 Design Direction & Principles
At this point, we knew what we needed to build.
The next step? Making sure it felt trustworthy, unintimidating, and clear AF.
This wasn’t about flashy UI.
It was about showing clients — with every click — that they were in control.
🧭 Design Principles We Followed
🧊 1. Clarity Over Cleverness
→ Avoid abstract labels or “creative” scope names
→ Use plain language, bullet points, and phased sections
“I need to know what I’m getting — not read a pitch deck.”
— Internal reviewer, early build
🛡️ 2. Build-In Trust, Don’t Just Talk About It
→ Add badges, creator bios, and verified stats before checkout
→ Surface refund policies and secure payment info early
→ Make the system feel safe to explore
👁️ 3. Always Show What’s Next
→ Preview team roles and open slots
→ Break scope into clear milestones
→ Use tooltips to explain why something matters
💬 4. Keep the UX Calm
→ Remove “loud” CTAs until the user is ready
→ Add review screens before commitment
→ Keep the experience emotionally steady, not pushy
🖼️ Visual System Highlights
Scope Preview: Phased deliverables with edit toggles
Team Assembly: “Need 4 / Have 2” bar with open roles listed
Sidebar: Trust badges, average project duration, team bios
Tooltips: Inspired by Etsy, Target, and Best Buy — explain things in one sentence
Checkout: Klarna-style monthly pricing + refund badge visible before “Start Project”
🧪 One Rule We Kept Asking:
“Would this screen give a non-technical buyer enough confidence to move forward?”
If the answer was “ehhh maybe,” we kept tweaking it.
🧱 Wireframes
Once we had our strategy and design principles locked in, we started bringing it all to life — one screen at a time.
Our goal wasn’t just to “redesign” the interface.
It was to de-escalate the entire experience.
Make it calm. Make it clear. Make it feel like a good decision.
✏️ Low-Fidelity Wireframes
We started with quick layout sketches to figure out structure:
Where does the trust info go?
What comes first — team invites or scope review?
When should someone see payment options?
These helped us test flow before getting caught up in colors or UI polish.
🎛️ Mid-Fidelity Wireframes
This is where things started getting more real.
Scope Preview
Clean breakdown of deliverables by phase
Toggle to expand/collapse scope sections
Light grey edit indicators so nothing felt “locked”
Team Assembly
“Need 4 / Have 2” visual tracker
Invite cards with role, status, and profile preview
Option to proceed with unfilled roles (but clearly flagged)
Sidebar (aka Confidence Panel™)
Pricing + payment plan
Badges (e.g. “Verified Creator,” “Agency Award Winner”)
Refund policy + estimated project length
Checkout Flow
Step-by-step: Review → Payment → Confirmation
Klarna-style “$833/mo for 24 months” breakdown
Tooltip icons for everything — from what’s included to how refunds work
🎯 Why We Skipped High-Fidelity for Some Screens
Since the product hadn’t launched yet, we kept a lot of the layout work in mid-fi to stay agile and test fast.
Only a few screens made it to high-fidelity — and even those were focused more on feel than final visuals.
🧪 What These Wireframes Solved
Clients could see what they were buying
Team structure was transparent and flexible
The “Start Project” button no longer felt like a trap
And overall, everything was just... calmer
🔁 Iteration & Feedback
Even before launch, we knew we couldn’t just ship and hope for the best.
So we tested, we asked questions, and — no surprise — users gave us plenty of things to fix.
This wasn’t about perfection.
It was about listening, adjusting, and making the product feel like it had someone on the other end paying attention.
🧪 Mid-Fidelity Testing Highlights
We ran early usability tests using mid-fi wireframes and had participants walk through 3 core tasks:
Review the scope and make changes
Invite team members to the project
Complete checkout with payment preferences
Here’s what we heard:
“I like the layout — but I wish I could preview everything before committing.”
“Wait, do I have to fill all the team roles before checkout?”
“The pricing looks great, but I had to scroll to find the payment options.”
💡 Okay. So that meant:
Add a full review step before the CTA
Make open roles + optional invites super clear
Pull trust signals (badges, refund policy, Klarna) into the sidebar earlier
🎨 Iteration Example: The Checkout Flow
Original:
One big “Start Project” button
No confirmation screen
Payment info came after clicking the CTA
Feedback:
“This feels like I’m getting locked into something.”
Iteration:
New “Review & Confirm” screen with full summary
Klarna-style pricing moved above the fold
Add tooltip: “This step doesn’t charge you — it just finalizes your setup”
🧠 What We Took Away
Even small changes had a big impact on how users felt:
Adding a review screen made people relax
Showing team status in plain language removed guesswork
Explaining terms in tooltips helped people trust what they were seeing
This round of feedback helped us shift the product from functional to reassuring — which, in a services marketplace, is everything.
🧪 User Testing (Mid + Hi-Fi)
We ran two rounds of usability testing — one using mid-fidelity wireframes and one using high-fidelity mocks with refined flow logic and interface polish.
The goal wasn’t just to see if people could click through the flow.
We wanted to know:
🧠 Did they understand it?
😌 Did it feel safe?
✅ Did it feel like something they could actually use?
🔍 Mid-Fidelity Test
We asked users to complete three core tasks:
Customize the scope (edit or remove deliverables)
Invite team members (or proceed solo)
Check out using payment options
We also asked them to rate how difficult each task felt on a scale from 1 (very easy) to 5 (very hard).
💬 Feedback Highlights:
“I wasn’t sure if I was supposed to invite everyone now or later.”
“The list of deliverables was kind of overwhelming at first.”
“Once I saw the refund policy, I felt better — but I wish it showed up sooner.”
What changed:
Added live invite status tracker (“Need 4 / Have 2”)
Broke deliverables into collapsible phases
Moved trust language higher in the sidebar
🎯 High-Fidelity Test
We tested the updated checkout flow with Klarna-style breakdowns, live team status, and full scope summaries. Participants walked through the same three tasks again — this time with everything more polished.
We also tested two variations of the team invite screen:
Version A: Card-style invites with role previews
Version B: Dropdown selection for each role
Users preferred Version A because it felt more visual and “less form-like.”
💬 Favorite Feedback:
“This feels like buying something on Amazon — but I actually know who’s doing the work.”
“I liked that it showed me what’s next, not just what’s now.”
💡 What Still Needed Work:
Some users wanted clearer labels for what’s editable vs. fixed in the scope
A few participants asked for the ability to invite teammates after checkout (for async hiring)
🧠 Overall Testing Takeaways
✅ Scope clarity = confidence
✅ Trust signals reduce drop-off
✅ Simple tooltips solve more than you think
✅ Checkout is emotional — not just transactional
Testing helped us stress-test the entire experience before launch — and made sure that when users click “Start Project,” they’re not guessing anymore.
📈 Results / Impact
Since the product hasn’t officially launched yet, we don’t have hard metrics — but that didn’t stop us from measuring impact.
Instead of conversions or retention (yet), we focused on:
What changed after the redesign
How users felt during testing
What would’ve gone wrong if we hadn’t caught this stuff early
✅ What We Fixed Before It Could Become a Problem
Original experience:
Scope editing felt risky
Inviting a team was confusing
“Start Project” felt like falling off a cliff
Redesigned experience:
Scope is broken into editable, collapsible phases
Team invites show who’s assigned, needed, and optional
Checkout includes full review, payment options, and refund policies before commitment
We didn’t just redesign the UI — we redesigned the emotional arc of launching a project.
🧪 What Users Said Post-Redesign
“I would actually go through with it now. Before, I wasn’t sure I was ready.”
“This feels like something built for someone like me — not just dev teams.”
“It’s clear, it’s calm, and it feels like I’m in control.”
📊 What We Expect to See Post-Launch
These are the metrics we’ll track once it’s live:
Decrease in checkout drop-off
Increase in invite completion rate
Faster time-to-project-start
Higher trust scores during onboarding surveys
We designed with these goals in mind — and the testing results so far give us strong signals that we’re on the right track.
🧭 Reflection & Next Steps
This project reminded me that clarity is the most underrated UX feature.
It’s easy to design something that works.
It’s harder to design something that feels safe — especially when people are making big decisions involving money, teams, and long-term outcomes.
What started as “cleaning up a flow” turned into a full rethink of how clients launch scoped projects with confidence. And honestly? I’m glad we caught it before shipping.
💡 What I Learned
Just because something is functional doesn’t mean it’s reassuring
Emotional UX is real — trust needs to be designed, not assumed
Users will always give better feedback than you expect, if you give them space to talk
And most importantly:
“Start Project” should never feel like a leap of faith.
🔮 What’s Next
If I had more time (or dev resources), I’d love to explore:
Smart Invite Recommendations: AI-powered team match suggestions based on role gaps + timeline
Scope Simulation Mode: Let users test changes before applying them
Invite After Checkout: Let clients start with a core team, and fill in roles later without friction
Saved Teams / Templates: Especially for agencies launching multiple projects at once
All of these build on the same goal:
Give users more clarity, more flexibility, and more control.
This project was never about flashy features.
It was about building an experience that says:
“You’ve got this — and we’ve got your back.”