Mark – B2B SaaS, 41 employees, Series A – hired an agency for a dashboard redesign. Three months, $35,000, “a senior full-stack designer with eight years of UI/UX design and development experience.” Seamless handoff. No communication gaps. One person who thinks in both languages.
Week ten of an eight-week project, Mark asked the designer to explain a CSS grid issue in the live build. Something wasn’t rendering correctly on smaller viewports and he wanted to understand the decision.
The answer came back: “Let me check with our development team.”
Mark typed back: “You are the development team.”
Nobody replied for six hours.
That was the moment he understood what he’d actually bought.
How the Mechanic Works
Agencies bundle UI/UX design and development for three reasons, and none of them are about quality.
The first is margin. A genuine full-stack designer – someone who opens Figma in the morning and VS Code in the afternoon – commands $120 to $180 per hour because they’re genuinely rare. A junior designer and a bootcamp-trained developer, hired separately and managed through a PM, cost $90 to $110 per hour combined. Sell them as one person at $140 per hour and the math works out nicely. For the agency.
The second is lock-in. Once you’ve commissioned design work from an agency, switching developers mid-project means handing someone else’s Figma files to a new engineer and hoping they can interpret them. The friction keeps you paying.
The third is positioning. “Full-stack designer” sounds like a specific expertise. “Junior designer plus outsourced developer” sounds like what it is. Most clients can’t tell the difference until month two. By then, they’ve paid half.
This isn’t a scam in the criminal sense. It’s just economics dressed as service design.
What Mark Actually Paid For
Mark’s $35,000 broke down like this:
The designer was based in Portland. Two years of experience, strong Figma skills, no production code in her portfolio. She billed at $150 per hour for 120 hours across the project. Total: $18,000. Her job was mockups, client calls, and revisions.
The developer was based in Lviv. Bootcamp graduate, eighteen months of professional experience, never opened Figma in a professional context. He billed the agency at $50 per hour for 200 hours. Total: $10,000. His job was to build whatever the designer specified.
The agency took $7,000 for project management – a PM whose full-time role was translating between two people who should have been one.
Mark thought he was paying for a senior full-stack designer who makes decisions that work in both Figma and React simultaneously. What he got was two people who had never spoken directly, coordinating through a project manager who understood neither design nor development well enough to catch the gaps between them.
The gaps showed up in the details. Figma specified an 8px grid. The build used 4px. The designer called for Inter. The developer shipped Roboto. Mockups showed 24px border radius. Live site had 16px. Small things individually. Collectively, the difference between a product that feels considered and one that feels like it was assembled by people who never met.
They hadn’t.
Why the Details Always Miss
The core problem with two people pretending to be one full-stack designer isn’t coordination overhead, though that’s real. It’s that each person optimises for their own context without understanding the other’s constraints.
The designer specified a smooth carousel animation on the main dashboard. Beautiful in Figma. The developer built it, then flagged that the animation was adding 40kb to the bundle and causing layout shift on slower connections. The designer’s response: “Can’t you just optimise it?” The developer’s response: “Not without rebuilding the component.”
A real full-stack designer makes that trade-off before it becomes a problem. They know what smooth animations cost in bundle size because they’ve written the code. They design within constraints they understand from experience, not constraints they learn about in week eight when the developer finally escalates.
Mark’s project ran eight weeks over schedule. He asked the designer why the onboarding flow had eleven steps when the old one had six. She said it felt more complete. She hadn’t discussed it with the developer. The developer built it as specified. Nobody had thought about what eleven steps costs in activation rate until users started dropping off in testing.
That’s what happens when the person making design decisions has never had to implement them.
The Questions That Reveal It
Mark missed the signs during evaluation. In retrospect they were visible.
The first was response latency. Simple questions – “can we add a dropdown here,” “what’s the timeline on the filter component” – came back within an hour. Complex questions that required both design and technical judgment took 24 hours minimum. The agency PM was translating between two people, and translation takes time.
The second was asymmetric revision speed. Design changes were fast. Figma is fast. Move a sidebar from right to left: twenty minutes. Code changes for the same revision: three days, because moving a sidebar in a component-based system means refactoring layout logic, testing breakpoints, checking z-index stacking across pages.
A real full-stack designer quotes both timelines at once because they’ve done both. An agency quotes the design timeline and discovers the development timeline later.
The third was the question deflection pattern. Any question that touched both disciplines got deflected to the other one. Mark asked the designer about performance on slower devices. “Our development team handles performance.” He asked the developer why a component was implemented a particular way. “Based on the design specifications provided.”
Neither could explain the other’s decisions. Because they hadn’t made them.
When you’re evaluating whether you’re hiring a genuine full-stack designer or two people with one agency email, ask three things:
“Show me a commit you made this month.” A real full-stack designer opens GitHub. Two people say “let me get back to you” or “our workflow doesn’t use public repos.”
“What’s the last technical constraint that changed a design decision?” A real answer is specific: “Wanted a smooth carousel but the bundle cost wasn’t worth it, switched to click navigation.” A fake answer is structural: “We coordinate design and development to ensure technical feasibility.”
“Walk me through how you keep Figma and code in sync.” Real: explains design tokens, CSS variables, how changes propagate. Fake: “Design team manages Figma, development team implements, PM ensures consistency.” That last sentence means it’s not consistent.
What the Second Hire Looked Like
Mark’s project shipped in week sixteen. The dashboard worked. It looked fine. Not what he’d envisioned, but functional.
He spent $35,000 and four months on it. Then he hired someone else to do the next phase.
The second hire was a senior full-stack designer – genuinely. Opens terminal. Writes components. Commits to Git. Reviews PRs. The kind of person who designs a component with its states already mapped because they know what undefined states cost in engineering time.
Cost: $28,000 for the same scope. Timeline: nine weeks. No PM required because no translation required.
The Figma files matched the code because the same person made both. Questions got answered in the same conversation because the same person held both contexts. Revisions were quoted accurately because the person quoting them was the person doing them.
That’s what integrated UI/UX design and development actually means. Not two people through Slack. One person who thinks in both languages from the start.
The difference in outcome wasn’t talent. The Portland designer and the Lviv developer were both competent people doing reasonable work in their own domains. The difference was that pretending two people are one creates coordination overhead that compounds across every decision, every revision, every question that touches both sides of the work.
If You Can’t Find One, Hire Two Honestly
Genuine full-stack designers are rare. If you can’t find one – and you often can’t, because the market for people who design well and code well is thin – the right answer isn’t to hire an agency that bundles two juniors and calls it senior.
The right answer is to hire a designer and a developer separately, explicitly, with clear ownership of each domain and a process for handoff that doesn’t rely on a PM playing telephone.
That setup has coordination costs too. But they’re visible. You know who’s responsible for what. You can see where the gaps are. You’re not paying $7,000 for a project manager to translate between two people who should have been talking directly.
Mark’s $35,000 lesson: the coordination overhead doesn’t disappear when an agency bundles it into one line item. It just becomes invisible until week ten, when your designer asks their development team a question and their development team is them.
Ask early. The answer tells you everything.