Unlimited requests. A queue that actually ships.
Submit as many UX design requests as you want. We work through them in focused active slots — one request at a time until it's done and shipped, then we pull the next. No juggling, no half-finished screens.
Onboarding flow rework
Pricing page redesign
Empty states pass
Docs IA cleanup
Homepage hero + offer
Dashboard metrics rail
Signup form UX
Mobile nav pattern
Feature pricing table
Settings redesign
Unlimited backlog. Fixed active slots.
Your backlog is unlimited. Load it with every screen your team has been deferring — the onboarding flow that needs rethinking, the pricing page that isn't converting, the dashboard that nobody finds useful. Priority is yours to control: reorder anytime, and the queue immediately reflects your updated sequence.
What we deliberately control is how many of those requests are in active design at once. Your plan determines the number of active slots — typically one or two. When a request enters an active slot, it has our full attention. We don't split context across ten things. We finish it, ship it, and only then pull the next request off the top of your backlog.
The result is a design pipeline that moves steadily and ships completely finished work rather than a constant stream of almost done items. You always know what's being worked on, what's waiting, and what shipped. See what types of requests we handle.
Constraint is the feature.
Most design bottlenecks aren't caused by too few designers — they're caused by too many things trying to move at once. Active slots enforce the kind of focus that produces quality and speed simultaneously.
Parallel tasks cost more than you think
Context-switching across ten active requests doesn't produce ten results in parallel — it produces ten results that are each 40% worse and 60% slower. Active slots eliminate that tax by design.
Revisions are faster when a request is still active
When we finish a request and ship it, we hold full context. Feedback at that moment is fast to act on. Revisions attached to an open request rarely take more than a few hours.
Predictable throughput over vague capacity
Two active slots means you always know roughly how long each new item waits. That is more useful to a product team than a theoretical promise of unlimited simultaneous work.
What a queued request looks like in practice.
Write requests the way you'd brief a colleague. Plain language, the goal, and any constraints. We handle the design thinking.
“Rework our pricing page layout”
Restructure the plan comparison, sharpen the CTA hierarchy, and fix the mobile fold.
“Redesign our onboarding flow”
Trim friction at signup, add a first-run checklist, and give new users a clear activation path.
“Clean up the reporting dashboard”
Surface the two metrics that matter, reduce visual noise, and make the filter bar scannable.
“Wireframe a new settings section”
A low-fidelity layout your engineers can scope before we move to full-fidelity screens.
“UX audit our checkout flow”
A prioritised list of drop-off points with before/after design recommendations.
“Standardise our modal components”
One Figma-native modal system covering all confirmation, form, and alert variants.
“Improve the hero section CTA”
Test copy direction, button treatment, and sub-copy to stop the page from leaking clicks.
“Build a clickable prototype for investors”
A polished Figma prototype showing the core user journey — ready to demo, ready to share.
Five columns. Nothing lost between them.
Every request moves through Backlog → Active → Review → Revised → Shipped. You can see exactly where each item sits at all times.
Onboarding flow rework
Pricing page redesign
Empty states pass
Docs IA cleanup
Homepage hero + offer
Dashboard metrics rail
Signup form UX
Mobile nav pattern
Feature pricing table
Settings redesign
Backlog
Everything you've submitted that isn't in active design yet. Reorder it whenever your priorities shift.
Active
The request is in design. We hold full context here and work until it's ready to hand off.
Review
Design is complete and in your court. Leave feedback, approve, or mark it for revision.
Revised
Feedback has been acted on. Final version is ready. One more look before it ships.
Shipped
Organised Figma file, build notes, and component specs delivered. The slot is now free for the next request.
What to expect and when.
These are honest estimates based on scope and plan tier — not marketing copy. Complex requests take longer. Clear briefs go faster.
48–72h
First update on entry
For a new request entering an active slot on the Standard plan, you'll see a first design pass within two to three business days. Single-screen or section requests often come in faster.
< 24h
Revision turnaround
Revisions on an active request come back the same or next business day. The faster and clearer your feedback, the faster the revision — there's a direct relationship.
Priority
Faster lane available
Priority queue subscribers move to the front of active slots. If time-to-first-design matters more than cost, see plan tiers.
Scope affects timing. A single hero section and a full SaaS redesign both enter the queue the same way, but they have very different completion timelines. We'll tell you upfront if a request is larger than typical.
Unlimited revisions, zero slot cost.
Revisions on an active request are unlimited and do not consume an additional slot. A revision is part of the same request lifecycle — we don't close the card and open a new one every time you leave feedback.
The revision loop works like this: design ships to Review, you leave feedback on the Figma file or in the task, we act on it and push back to Review. That cycle repeats until you're satisfied. There's no cap on how many cycles you can run.
The one thing that accelerates revisions more than anything else is specific feedback. "The CTA needs to be more prominent" takes half the time to act on compared to "something feels off." We'll coach you toward clear feedback early in the relationship so the loop stays tight.
Once you mark a request Shipped, it's complete. If you want to revisit it substantially later, that becomes a new request in your backlog — which is fine, because your backlog is unlimited.
What you receive when a request ships.
Shipped doesn't mean a flat Figma artboard with no context. Every delivery is build-ready.
What's included
- Organised Figma file with named frames and layers
- Component specs: spacing, typography, colour tokens
- Interactive states: hover, focus, error, empty, loading
- Responsive layouts across breakpoints (when applicable)
- Build notes for your engineers in plain language
- Asset exports where needed (SVGs, icons, images)
- Handoff-ready prototype for stakeholder review
- Revision history so you can trace design decisions
What's not included
- Production HTML/CSS or front-end code
- CMS configuration or content entry
- Illustration and custom iconography (beyond basic icons)
- Copywriting beyond UX microcopy and labels
- Brand identity or logo design
- Animation production files (we design the motion; we don't produce it)
If your team uses vibe-code sessions, we can pair design delivery with a live build walkthrough so your engineers don't lose anything in translation.
Design queue, answered.
Unlimited means you can submit as many requests as you want and ask for as many revisions as you want. There is no cap on the size of your backlog. What is controlled is throughput: each plan gives you a fixed number of active request slots, so we work on a focused set of things at a time. That keeps quality high and turnaround predictable instead of spreading attention thin across a dozen half-finished tasks.
Load your backlog. We'll keep it moving.
Unlimited requests, fixed active slots, unlimited revisions. Pause or cancel anytime. No contracts.