A VP of Product at a Series B SaaS company. Their customer success dashboard launched 7 months ago. Support tickets are up 34% since launch. Users can’t find the data they need. The product team knows the interface is the problem. They decide to outsource UI UX design.
The agency deck is beautiful. Eight-week timeline. Three designers assigned. Component library included. The VP signs a $31,200 contract. Finally, they’ll ship something that works.
Twelve weeks later: Figma files delivered. 247 screens. The lead developer opens them, scrolls for 6 minutes, closes the tab. “This will take us 19 weeks to build. Maybe longer.” The CEO asks why they’re still not shipping. Nobody has an answer.
Companies treat “should we outsource UI UX design?” as a budget question. Wrong. It’s a diagnostic question. Three specific questions reveal whether outsourcing creates value or creates a $47K backlog of unusable Figma files.
Most companies answer question #1 correctly. Question #2? Almost everyone fails it. Question #3 exposes organizational dysfunction they didn’t know existed. By the time they realize any of this, the contract is signed and the timeline is fiction.
These aren’t soft questions about “culture fit” or “readiness.” These are binary diagnostics. Pass all three, outsourcing works. Fail any one, you’re paying premium rates for organizational therapy.
Question 1: Can Your Team Articulate the User Problem Without Looking at Documentation?
If your PM needs to check Notion to explain what users struggle with, the agency will invent the problem for you.
This isn’t about documentation hygiene. It’s about whether your team has internalized the problem you’re solving. If they can’t explain the user’s pain point without checking Confluence, they can’t evaluate whether a design solves it.
When you outsource UI UX design, agencies ask questions. “Who’s using this?” “What are they trying to accomplish?” “What blocks them?” If your team responds with “Let me find the research doc” or “I think it’s in the PRD somewhere,” the agency builds on guesses. Those guesses are always wrong. The design is beautiful and solves a problem nobody has.
What passing looks like
Real example with lived-in details: Product: Scheduling software for HVAC contractors (competitor to ServiceTitan)
- PM explains instantly: “Dispatchers need to reschedule emergency calls while they’re driving between job sites, but our current flow requires 8 taps and they lose cell signal mid-flow”
- Designer adds: “The reschedule button is hidden under a three-dot menu, and 73% of dispatchers don’t find it within 30 seconds”
- Developer knows: “We’re seeing around 412 abandoned reschedule attempts per week because the session times out before they complete the flow”
Nobody checked a document. Nobody hesitated. They know this problem exists because they’ve watched dispatchers struggle with it. They’ve read the support tickets. They’ve sat in on user calls.
What this enables: Agency asks “What’s the user trying to do?” Your team answers in 30 seconds with specifics. First design iteration is 80% right instead of 35% right. You save around 3-4 revision cycles, which is 6-8 weeks.
What failing looks like
Real scenario with specific breakdown: Mid-market SaaS company (Greenhouse competitor, 200 customers) decides to outsource redesign of their interview scheduling flow.
Agency kickoff call:
- Agency: “What’s the main pain point for recruiters?”
- PM: “Let me pull up the research… I know we did interviews last quarter…”
- Agency: “What decisions do they make in this flow?”
- Designer: “I’d have to check with Product on that one.”
- Agency: “How many recruiters abandon the flow?”
- Developer: “Not sure, I can query that this afternoon.”
The kickoff call ends. Agency has no solid answers. They build based on assumptions: “Recruiters probably want more candidate data visible.” Wrong. Recruiters needed faster scheduling, not more information. They were overwhelmed, not under-informed.
Design delivered. Every screen optimized for data display. Company requests full revision. Additional costs: $38,700 (revision work, extended dev time, 11-week delay). Timeline doubles from 8 weeks to 19 weeks.
The actual failure: You didn’t outsource the design work. You outsourced the problem definition. Agencies can’t define your users’ problems. If you don’t know the problem cold, they’ll invent one. You’ll pay premium rates to solve the wrong problem beautifully.
The diagnostic
Send this exact email to three people (PM, one designer if you have one, one developer):
“Reply to this email without checking any docs: In 2-3 sentences, explain the main problem our users face in [specific feature]. Include what they’re trying to accomplish and what’s blocking them.”
If they give three different answers, you fail. If anyone says “let me check the research,” you fail. If answers are vague (“users are confused”), you fail.
Don’t outsource until all three answers match and include specifics.
Question 2: Do You Have Developer Capacity Already Allocated to Implement the Design? (Most Companies Fail This)
Your developers are slammed. That’s why you’re outsourcing. That’s also why outsourcing will fail.
Connection to Question 1: If you failed Question 1, you’ll definitely fail Question 2. Here’s why: When your team doesn’t understand the user problem, the design will need major revisions. Major revisions require developer input. Developer input requires developer time. If they don’t have time for input, they definitely don’t have time for rework.
Why most companies fail this
Companies decide to outsource UI UX design because their developers are underwater. The logic sounds reasonable: “Our devs are finishing Q3 features, so let’s outsource design. By the time mockups are ready, devs will be free to implement.”
This logic is backwards and expensive.
What actually happens:
- Weeks 1-8: Agency designs while devs ship features
- Week 9: Design delivered. Devs still finishing features (now Q4 priorities shifted in)
- Weeks 10-13: Design sits in Figma. Devs complete current work (around 4 weeks behind)
- Week 14: Devs finally review design. Find 27 technical issues (“This dropdown won’t work with our data structure,” “This animation will tank mobile performance,” “This requires API changes we can’t make”)
- Weeks 15-17: Revision cycle with agency (3 weeks)
- Week 18: Second review. Find 14 more issues.
- Weeks 19-20: Second revision cycle
- Week 21: Final approval
- Week 22: Agency contract ends. Devs start implementation.
- Week 33: Feature ships (12 weeks after implementation starts)
Timeline: 33 weeks. You paid for 8.
The design sat untouched for 13 weeks. By the time devs implemented it, your product had changed. The design solved July’s problems in October.
The hidden cost math
Real scenario with complete breakdown: Series B SaaS company (competitor to HubSpot, 4,200 users). Four developers. Decides to outsource UI UX design for their lead scoring interface.
What they budgeted:
- Agency design: $27,300
- Timeline: 8 weeks
- Deliverables: Figma files, component specs, interactive prototype
What they didn’t budget:
Developer costs (internal):
- Initial design review: 17 hours across 3 devs ($2,414 at $142/hr blended rate)
- Feedback documentation: 9 hours ($1,278)
- Revision review rounds: 11 hours ($1,562)
- Implementation: 83 hours across 2 devs ($11,786)
- Bug fixes from spec mismatches: 19 hours ($2,698)
PM coordination overhead:
- Agency sync meetings: 8 meetings × 1.5 hours = 12 hours ($1,680 at $140/hr)
- Slack coordination: roughly 247 messages over 21 weeks
Opportunity cost:
- Lead scoring feature was supposed to ship in Q3
- Shipped in Q4 instead
- Lost potential revenue from 11-week delay: around $67K based on projected conversion lift
Total project cost: $47,156 in direct costs + $67K opportunity cost Total timeline: 21 weeks (8 design + 13 implementation/coordination)
Timeline breakdown that adds up:
- Weeks 1-8: Agency designs
- Week 9: Handoff meeting, dev review begins
- Weeks 10-11: Agency revision cycle #1
- Week 12: Dev review #2, final approval
- Weeks 13-19: Implementation (7 weeks for 83 hours across 2 devs)
- Weeks 20-21: Bug fixes, spec clarifications
What they thought they were buying: $27,300, 8 weeks What they actually paid: $114,156 all-in, 21 weeks
The $86,856 gap is organizational friction. Nobody saw it coming. The CFO definitely noticed it leaving.
What passing looks like
Before signing the agency contract, you’ve:
- Blocked specific developer time on the engineering calendar – not “after current sprint,” but actual dates
- Moved Q4 features out of those weeks and communicated the trade-off to leadership
- Assigned two specific developers by name to implementation
- Confirmed with engineering leadership that these developers won’t get pulled for incidents or critical bugs
- Set up weekly design review sessions on the calendar before design work even starts
The mockups land on a Tuesday. Implementation starts Thursday. The design doesn’t collect dust.
What failing looks like – three variations
Variation 1: The “We’ll be ready” failure Company assumes devs will be free “sometime in Q3.” Q3 arrives. Devs are implementing a major customer request. Design waits 6 weeks. By week 6, the agency’s lead designer rolled off to another project. You’re working with their junior designer for revisions.
Variation 2: The “Incident cascade” failure Devs are scheduled to implement design. Week 1: Production incident takes 3 days. Week 2: Customer-reported security issue takes 4 days. Week 3: CEO commits to demo at conference, needs emergency feature. Design implementation pushed by 7 weeks. Agency contract expired. You’re on your own.
Variation 3: The “We underestimated” failure Devs review design. “This will take 90 hours, not 50.” Engineering manager: “We don’t have 90 hours.” PM: “Can we simplify?” Back to agency for simplification. Design gets watered down to fit capacity. You paid premium rates for a design you then had to compromise. Should have started with the constraints.
The pattern: If you don’t have capacity before you outsource, the design becomes shelfware. Expensive, beautiful shelfware.
Question 3: Can You Make Design Decisions in 48 Hours or Less?
If it takes your team 9 days to approve a button color, the 8-week design project will take 24 weeks.
Connection to Questions 1 & 2: Failed Question 1? Your feedback will contradict itself because nobody agrees on the problem. Failed Question 2? Your feedback will be “make it simpler so we can build it faster.” Both failures make Question 3 impossible.
What this tests
This isn’t about speed for speed’s sake. It’s about whether your organization can review design work and provide clear, consolidated direction without approval theater.
When you outsource UI UX design, the feedback loop runs 5-7 times on average. Agency sends mockups. You review. You send feedback. They iterate. Repeat.
If each cycle takes 5 business days (tight but reasonable), that’s 25-35 business days of iteration – around 5-7 weeks. Fine.
If each cycle takes 12 business days (realistic at companies with approval chains), that’s 60-84 business days – roughly 12-17 weeks. The 8-week design project now takes 25 weeks. You’re paying holding costs. The agency loses momentum. Everyone’s frustrated.
What passing looks like
Efficient cycle at a Series A fintech company:
- Monday 9am: Agency sends dashboard redesign mockups via Figma link
- Monday 2pm: PM reviews, schedules 30-minute sync with VP Product and Head of Engineering
- Tuesday 10am: Three-person review meeting. Decisions made in the room. PM takes notes.
- Tuesday 4pm: PM sends consolidated feedback doc to agency. Six specific changes. No contradictions.
- Wednesday 11am: Agency responds with clarifying questions on two points
- Wednesday 3pm: PM answers via Slack
- Thursday: Agency iterates
- Friday 2pm: Updated version ready
Total cycle time: 5 business days. Six revision cycles = 30 business days (6 weeks). The 8-week design project takes 14 weeks total. Reasonable. Nobody’s waiting on anyone.
What failing looks like – with stakeholder politics
Realistic scenario at a Series B HR tech company (170 employees, competitor to Lattice):
Monday 9am: Agency sends performance review interface redesign Monday 11am: PM reviews, schedules stakeholder meeting
The stakeholder meeting (Friday 2pm, 90 minutes scheduled):
- VP Product (wants data-heavy interface)
- Head of Customer Success (wants simpler interface based on support tickets)
- VP Engineering (wants whatever’s fastest to build)
- Head of Design (wasn’t included in vendor selection, has opinions about the agency’s approach)
- CEO (pops in for 10 minutes, asks “why doesn’t it look like Lattice?”)
- Marketing Director (concerned about brand consistency)
Meeting outcome:
- 23 feedback items
- 7 of them contradict each other
- Head of Design requests meeting with agency directly
- VP Engineering says “this will take 140 hours to build, can we simplify?”
Tuesday-Thursday: PM tries to consolidate contradictory feedback Following Monday: PM sends 2,100-word feedback doc to agency Tuesday: Agency responds: “Items 4, 7, and 12 conflict. Which direction?” Wednesday: PM schedules another stakeholder meeting to resolve conflicts Following Tuesday: Clarification sent
Total cycle time: 12 business days per iteration
Six iterations = 72 business days (roughly 14 weeks). The 8-week design project takes 22 weeks. The agency spent 8 weeks designing and 14 weeks waiting for your organization to make decisions.
The expensive part: Some agencies bill for extended timelines. Some lose their best designers to other projects. All of them deliver worse work when they’re waiting 64% of the time. Your revision cycles aren’t clean because your feedback isn’t aligned.
The diagnostic
Before you outsource, track this:
Pull up your most recent design decision (doesn’t have to be major – new feature layout, button placement, navigation change).
Mark these timestamps:
- When was the design option first presented?
- When did the final “approved, ship it” decision happen?
If more than 3 business days passed: Your organization isn’t ready to outsource UI UX design efficiently. You’ll pay for your feedback friction.
Common failure patterns:
- Decision-maker unavailable (traveling, in back-to-back meetings)
- Too many stakeholders with veto power
- Feedback comes from people who weren’t in the brief
- Design review happens in Slack threads, not consolidated meetings
- “Let’s sleep on it” becomes “let’s revisit next week”
Fix the decision-making bottleneck before you sign a contract. Or budget an extra 60% timeline buffer and accept that you’re paying premium rates for your organizational dysfunction.
These three questions don’t test whether you should outsource. They test whether you’ve built the internal conditions that make outsourcing work.
Fail Question 1: You’ll commission beautiful solutions to problems nobody has. Fail Question 2: You’ll create a backlog of unusable Figma files while your developers ship other work. Fail Question 3: You’ll pay premium rates while your organization learns to make decisions.
Most agencies won’t tell you this. They’ll take your money and deliver what you asked for. The design will be beautiful. It will also sit unused for 17 weeks while you figure out what to do with it.
Fix your internal conditions first. Or accept that you’re paying agencies to expose your organizational problems.
We’re strict about this because we’re on your side.