A designer’s portfolio can feel like a highlight reel: polished screens, perfect mockups, tasteful type. And yes, good taste matters. But founders don’t hire “taste.” Founders hire someone who can turn messy goals into clear decisions, ship work that fits real constraints, and make the product feel simpler on the other side of the sprint.
That’s why the portfolio review needs a different lens. Not “Do I like this style?”, but “Can this person solve problems like ours? Can they design for tradeoffs, timelines, edge cases, stakeholders, and handoff; the unglamorous realities that decide whether a design actually launches?”
This checklist is built for that moment when you’re staring at 20 tabs and trying to pick one designer who will move the business forward. It helps you spot real product thinking, strong UX judgment, and execution you can ship without turning the hiring process into a months-long marathon.
Because the best portfolios don’t just show what someone made. They show how they think, how they collaborate, and how they measure “better.”
The 60-Second Portfolio Scan (What Founders Should Look for Fast)
Before diving into case studies, do a quick scan to answer one question: Is this portfolio worth 20 more minutes? A strong designer makes the “why” obvious early, so you’re not hunting for context across a maze of glossy screens.
Here’s what to look for in the first minute:
Clear role fit in one glance
The best portfolios signal what they actually do: product design, UI/visual, brand, web, growth, UX research, or a mix. If it’s unclear, the hiring process becomes guesswork. Look for a headline, project labels, or case studies that clearly match the type of work you need shipped.
Depth, not just variety
A portfolio with ten projects can still be shallow. What you want is evidence of ownership and problem-solving. Prioritize candidates who show at least 1–2 deep case studies where you can see the situation, the decisions, and the result, not just a gallery of final screens.
Context appears early
Strong designers don’t make you scroll to discover the basics. In the first few lines of a project, you should find:
- What was being built
- Who it was for
- What “success” meant
- What constraints shaped the work
If those are missing, it’s harder to judge whether the work is strong or just styled well.
Signs they design for real life
You’re hiring someone to ship outcomes, so scan for hints of shipping reality:
- Flows (not single screens)
- States (loading, empty, error)
- Mobile considerations
- Components or system thinking
Even one screenshot of a flow map, component library, or annotated handoff can reveal how production-ready their mindset is.
One quick “craft” gut-check
You don’t need to be a designer to spot fundamentals. Look for:
- Readable hierarchy
- Consistent spacing
- Thoughtful typography
- Buttons and UI that feel intentional
This isn’t about personal style. It’s about clarity and control.
Fast red flags that usually waste time
If you see these patterns repeatedly, move on quickly:
- Only “hero shots” and no case studies
- Beautiful work with zero explanation
- Projects that feel like templates with swapped colors
- No mention of constraints, collaboration, or outcomes
A portfolio should earn your attention, not demand your patience. This scan helps you shortlist designers most likely to bring clear thinking, strong execution, and real momentum to your product.
Portfolio Checklist Founders Should Use (Copy/Paste Scorecard)
Once a portfolio passes the quick scan, switch from “vibes” to evidence. Use the checklist below to evaluate each candidate the same way, so the decision doesn’t depend on who looked best at midnight after your fifth tab.
Role fit & scope (Are you hiring the right kind of designer?)
- The portfolio clearly matches the role (product, web, brand, growth, UI, research)
- Projects resemble your environment (startup pace, B2B/B2C, SaaS, mobile, marketplace, etc.)
- They show work at the level you need (features vs. systems, pages vs. products)
- Their “lane” is obvious: what they own end-to-end
Case study quality (Do they explain the work like a builder?)
- Each case starts with a clear problem statement
- Constraints are stated (time, tech, stakeholders, data, brand, legal, etc.)
- They explain key decisions and tradeoffs
- Iteration is visible (explorations, rounds, what changed, and why)
- You can tell what they did vs. what the team did (ownership is explicit)
- The story is coherent: problem → approach → decisions → output → result
UX judgment (Do they design for how users actually behave?)
- They show flows, not just screens (end-to-end journeys)
- Edge cases are considered (errors, permissions, empty states, onboarding gaps)
- Information architecture makes sense (navigation, labeling, hierarchy)
- The design simplifies complexity instead of adding steps
- Accessibility basics show up (contrast, focus states, readability)
Craft & consistency (Is the work clean, intentional, and usable?)
- Typography feels controlled (hierarchy is obvious)
- Spacing is consistent, and layouts feel balanced
- Components match across screens (buttons, inputs, patterns)
- Visual design supports clarity, not decoration
- Figma files look structured (naming, styles, components, organization)
Product thinking & business alignment (Do they connect design to outcomes?)
- They define what success means (goal, KPI, or proxy metric)
- They show how design supports conversion, activation, retention, or usability
- They can explain prioritization (what they cut, what they focused on, why)
- They understand user needs and business constraints
Collaboration & execution (Can they ship with your team?)
- Evidence of partnering with PM/engineering/marketing
- Handoff quality is visible (specs, annotations, component logic, QA notes)
- They mention feedback loops (design reviews, user input, stakeholder alignment)
- They design within constraints and still deliver shippable solutions
Proof of impact (Even lightweight)
- Outcomes are stated (numbers, directional improvements, qualitative wins)
- They share learnings (“what worked,” “what didn’t,” “what I’d change”)
- They show ownership through measurement or follow-up iterations
Professional signals (Trust, clarity, and ethics)
- Work is credited properly (team vs. individual contribution)
- They protect confidentiality while still showing thinking
- No “mystery projects” with unclear involvement
- Writing is clear and confident (easy to follow, easy to trust)
Quick scoring tip: Mark each section as Strong / Mixed / Missing. If case studies are “Missing,” it’s hard to evaluate anything else, no matter how polished the visuals look.
Pretty Portfolio Traps vs. Strong Portfolio Signals
A portfolio can look incredible and still be the wrong hire. Founders get burned when the work is optimized for admiration rather than for decision-making and shipping. The goal isn’t to find the most aesthetic designer; it’s to find the one who can make your product clearer, faster, and more usable under real constraints.
The “pretty portfolio” traps (what they often hide)
Hero shots with no story
If every project is a handful of gorgeous screens with zero context, you can’t see judgment. You’re looking at output without the thinking that created it.
Concept work that lives in a perfect world
Some portfolios are full of redesigns and “vision” projects where nothing had to ship. That usually means no deadlines, no stakeholders, no technical constraints, no edge cases, exactly the pressures your team will face.
Template case studies
When every case study follows the same generic structure, “research, wireframes, UI, done”, it can feel polished while revealing very little. Strong case studies show specific decisions and specific tradeoffs, not process buzzwords.
Style consistency that’s too consistent
If everything looks like the same brand, same layout, same vibe, you might be seeing a designer who designs one aesthetic rather than someone who can adapt to your product, your users, and your market.
Big claims with thin proof
“Improved conversion” or “boosted engagement” is easy to write. What matters is whether they explain how they measured success, or what signals they used when metrics weren’t available.
Strong portfolio signals (what you actually want)
Clarity shows up early
A strong designer makes the basics obvious: the problem, the audience, the constraints, and the goal right at the start.
Decisions are explained like a builder
You see the “why,” not just the “what.” They highlight tradeoffs, alternatives, and what they chose to simplify.
Real-world UX shows up in the work
Flows, states, edge cases, empty screens, error handling, these are the details that separate “looks good” from works in production.
Collaboration is visible
They reference partners, feedback loops, engineering constraints, and how alignment happened. That’s a strong predictor of how they’ll work with your team.
The work leaves a trail of impact
Even without perfect data, strong designers show outcomes: qualitative wins, learnings, iterations, and what changed after launch.
A portfolio doesn’t need to be flashy to be strong. It needs to be legible, honest, and grounded in reality, because that’s exactly what your product needs once the hiring decision becomes sprint planning.
Questions to Ask (That a Great Portfolio Makes Easy to Answer)
A portfolio review shouldn’t end with “Looks good.” It should end with clear evidence that this designer can handle the realities of your product: speed, ambiguity, trade-offs, and teamwork. The fastest way to get that evidence is to ask questions that force specific thinking, not rehearsed process talk.
Use these in your interview (or as a written follow-up). The best candidates will answer with concrete examples pulled straight from their case studies.
Problem & constraints
- “In this project, what was the real problem, not the requested feature?”
- “What constraints shaped the work the most: time, tech, stakeholders, data, brand?”
- “What did success look like before you designed anything?”
Decisions & tradeoffs
- “What were the top two options you considered, and why did you choose this one?”
- “What did you cut to keep the solution simple?”
- “What’s one design decision you’d defend if the team challenged it tomorrow?”
UX judgment & edge cases
- “Walk through the flow like a user. Where could someone get stuck?”
- “Which states mattered most: empty, loading, error, permissions—and why?”
- “What usability risk worried you, and how did you reduce it?”
Collaboration & execution
- “How did engineering influence this design?”
- “What pushback did you get, and how did you handle it?”
- “What did your handoff look like? What did you give developers to ship cleanly?”
Validation & impact
- “How did you validate the solution, including data, user feedback, support tickets, and stakeholder review?”
- “What changed after launch? What would you iterate next?”
- “If you had no metrics available, what signals would you use to judge whether it worked?”
Ownership & honesty
- “What part of this work was yours specifically?”
- “What did someone else own, and how did you collaborate?”
- “What’s one thing you learned the hard way from this project?”
Founder tip: If answers stay vague, repeat a single prompt: “Can you make that specific?” Strong designers can zoom in and show their reasoning without hiding behind jargon.
A Simple Scoring Rubric (So “Looks Good” Becomes a Clear Yes/No)
When you’re reviewing multiple portfolios, the hardest part isn’t spotting talent; it’s staying consistent. This rubric turns your review into a repeatable system, so you’re comparing designers on the signals that predict shipping, not on who had the slickest mockups.
Score each category from 1 to 5
Use this scale:
- 1 = Missing (no evidence)
- 3 = Solid (meets expectations)
- 5 = Exceptional (clear, repeatable strength)
The 5 categories that matter most
1) Case Study Clarity (1–5)
Do they explain the project like a builder?
- Problem + constraints are clear
- Decisions and tradeoffs are explained
- Ownership is obvious (what they did vs. the team)
2) Product Thinking & UX Judgment (1–5)
Do they design for real users and real flows?
- End-to-end journeys, not isolated screens
- Edge cases and states (empty/loading/error)
- Simplifies complexity with intent
3) Craft & Consistency (1–5)
Is the work clean, intentional, and usable?
- Strong hierarchy, spacing, typography
- Consistent components and patterns
- Visual design supports clarity
4) Execution & Shipping Readiness (1–5)
Can they get work across the finish line?
- Evidence of dev handoff, constraints, and iteration
- Works within timelines and tradeoffs
- Shows systems thinking (components, reuse)
5) Impact & Learning (1–5)
Do they connect design to outcomes?
- Metrics or meaningful proxies
- Post-launch learnings and iteration mindset
- Can explain what changed and why
How to interpret the score (fast)
- 22–25: Strong hire signal (great fit + high confidence)
- 18–21: Promising (validate with interview + references)
- 14–17: Mixed (only proceed if role is junior or scope is narrow)
- ≤13: Likely not the right fit
One “must-have” rule
If Case Study Clarity is a 1 or 2, treat that as a stop sign. Without clarity, it’s impossible to verify judgment, even if the visuals are stunning.
Different Checklists by Designer Type (So You Don’t Hire the Wrong Profile)
“Designer” can mean very different things. A portfolio might be strong and still miss your needs if the role is mismatched. Use the quick checklists below to evaluate candidates based on the job you actually need done.
Product Designer (End-to-end UX + shipping)
Look for:
- 2+ case studies with clear problem/constraints/decisions
- Flows across multiple screens (not single-page UI)
- Edge cases and states (empty/loading/error/permissions)
- Evidence of collaboration with engineering and PM
- Components or system thinking (patterns, reuse, consistency)
Green flag: They explain tradeoffs clearly and show what was shipped.
UI / Visual Designer (Polish + clarity + design systems)
Look for:
- Strong typography, hierarchy, spacing (craft is obvious)
- Consistent UI patterns and components
- Visual decisions explained (why this layout, why this hierarchy)
- Before/after improvements to clarity and usability
- Ability to adapt style to different brands/products
Green flag: They make interfaces feel effortless and coherent.
Web Designer (Marketing site performance + conversion)
Look for:
- Real websites, not only mockups (live links are ideal)
- Responsive design across breakpoints
- Conversion-focused structure (hero, proof, CTA, forms, pricing)
- Accessibility basics and performance awareness
- Collaboration with marketing/dev, plus iteration based on results
Green flag: They design pages that move users to action cleanly.
Brand Designer (Identity + system + consistency)
Look for:
- A full identity system (logo, type, color, rules), not just a mark
- Examples of brand applied across assets (web, socials, product, decks)
- Rationale behind choices (positioning, audience, tone)
- Consistency and restraint, not over-designing
- Clear guidelines that other teams can follow
Green flag: They build a brand system your team can actually use.
Growth / Performance Designer (Experiments + speed)
Look for:
- Fast iteration and testing mindset
- Landing pages, ads, email visuals, and onboarding experiments
- Hypothesis → design → result loop (even if results are directional)
- Ability to work within constraints and ship frequently
- Strong collaboration with marketing/product analytics
Green flag: They treat design like a lever, not a decoration.
UX Researcher (Evidence + insight → decisions)
Look for:
- Research plans, methods, and rationale (interviews, surveys, usability tests)
- Synthesis quality (themes, insights, opportunity areas)
- How findings influenced product decisions (not just reports)
- Stakeholder management and facilitation examples
- Ethical handling of data and participants
Green flag: They turn messy input into clear, actionable direction.
Common Red Flags (And What They Usually Signal)
Red flags don’t mean someone is “bad.” They usually mean the portfolio doesn’t give enough evidence for the kind of work you need shipped. Use these signals to save time, and to ask sharper follow-up questions when a candidate looks promising but unclear.
No real case studies (only a gallery)
If you only see final screens, you can’t evaluate judgment. This often signals:
- Limited ownership (they executed someone else’s direction)
- Work optimized for aesthetics over outcomes
- A portfolio built to impress, not to explain
Every project looks like the same style
Consistency can be great until it looks like one template. This often signals:
- A designer who’s strong in one aesthetic
- Less adaptability to different products, brands, and users
- Preference for visual polish over problem-solving
Vague language with no specifics
Phrases like “improved UX” or “boosted engagement” without proof often signal:
- Missing measurement
- Weak clarity on impact
- A case study written to sound impressive instead of showing evidence
No constraints mentioned anywhere
Design without constraints is a different job. This often signals:
- Mostly concept work
- Limited collaboration with engineering or stakeholders
- Less experience designing for tradeoffs, feasibility, timelines
No edge cases or states
If you never see empty/loading/error states, it often signals:
- A focus on ideal paths only
- Missing product thinking
- Less experience shipping production-ready UX
Unclear contribution (“We did…” with no detail)
Team work is normal; unclear ownership isn’t. This often signals:
- They were part of the project but not leading it
- Hard to predict how they’ll perform independently
- A portfolio that avoids accountability
“I did everything” with no explanation
A broad claim without specifics often signals:
- Inflated scope
- Missing collaboration detail
- A story that’s hard to trust without deeper questioning
Figma chaos (if they share files/screenshots)
Messy naming, inconsistent components, or scattered frames often signal:
- Weak systems thinking
- Harder handoffs
- More effort for engineering and QA
NDA-heavy portfolio with zero visible thinking
Confidential work is normal. No visible reasoning is a problem. This often signals:
- Over-cautious sharing
- Or a portfolio that lacks strong documentation habits
Founder move: When you see a red flag, don’t argue with it, ask for the missing proof. A strong designer can fill the gaps quickly with specifics, stories, and tradeoffs.
How to Run a Fast, Founder-Friendly Portfolio Review Process
A good hiring process protects your time and still finds the right person. This one is designed for founders who need signal quickly, and want to avoid endless loops, subjective debates, and “they looked cool” decisions.
Step 1: Do a 60-second scan (shortlist fast)
Open the portfolio and answer three questions:
- Is the role fit obvious (product, web, brand, UI, growth)?
- Are there 1–2 real case studies with context?
- Do I see signs of shipping reality (flows, states, constraints, handoff)?
If the answer is unclear, move on. Your pipeline stays clean.
Step 2: Deep dive into 1–2 case studies (10–15 minutes each)
Pick the most relevant projects and look for:
- Problem + constraints stated early
- Decisions and tradeoffs explained
- Evidence of iteration (what changed and why)
- What shipped (or what they’d do differently now)
This is where you’ll spot judgment, not just taste.
Step 3: Use structured interview questions (keep it evidence-based)
Run a short interview where the candidate walks you through one case study:
- “What was the real problem?”
- “What tradeoff did you make and why?”
- “What did engineering push back on?”
- “What changed after launch?”
A strong candidate will answer with specifics and show clear thinking under constraints.
Step 4 (Optional): one practical exercise (only if it adds clarity)
If you still need proof, choose one lightweight option:
- Live critique: give them a page/flow and ask what they’d improve in 20 minutes
- Small paid mini-task: a focused redesign of one flow with assumptions + tradeoffs
- Portfolio follow-up: ask for one extra case study write-up if the portfolio is thin
Keep it short. You’re testing judgment and communication, not free labor.
Step 5: Reference checks that actually help
Instead of “Were they good?”, ask:
- “What did they own end-to-end?”
- “How did they handle feedback and conflict?”
- “Did they ship reliably under constraints?”
- “Where were they strongest: craft, UX, systems, collaboration?”
References should confirm how they work, not just that they’re nice.
Step 6: Decide with your rubric (and document the why)
Use the scoring rubric from earlier and write one sentence per category:
- What’s the evidence?
- What’s the risk?
- What role will they thrive in?
This turns your decision into something you can defend, and repeat.
The Takeaway
A strong portfolio doesn’t just prove someone can make things look good. It proves they can turn ambiguity into decisions, design for real constraints, and deliver work your team can ship without friction.
That’s the designer who protects your roadmap, reduces back-and-forth, and makes the product feel easier to use release after release.
Use this checklist to stay consistent: prioritize case study clarity, UX judgment, and execution-ready thinking over surface-level polish. When those signals show up, you’re not betting on style; you’re hiring reliable momentum.
If you want to move faster and still hire with confidence, South can help. We connect founders with pre-vetted LATAM designers who combine strong craft with practical, product-minded execution, so you can add design capacity without adding chaos.
Schedule a free call with us and get matched with designers who fit your product, pace, and goals.
