Step 1: Pick a lane (for now), not forever

You don’t need to marry a specialty today. You just need a clear direction for the next 90 days.

Popular lanes in design + tech

• UI/UX Designer: research, wireframes, flows, interfaces, prototypes
• Product Designer: end-to-end problem solving (research → UX → UI → shipping)
• Visual/Brand Designer: identity systems, marketing assets, campaigns
• Interaction/Motion Designer: micro-interactions, animation, motion for product
• Design Engineer / Front-End: design-system savvy, builds production UI
• Content/UX Writer: microcopy, naming, flow clarity, product voice

If you’re unsure, start with UI/UX. It teaches user thinking, systems, and enough visual craft to move anywhere later.

Step 2: Learn the core skills (the “design muscle”)

No matter the lane, these fundamentals pay rent:

• Visual foundations: spacing, hierarchy, alignment, typography, color
• UX thinking: problem framing, research basics, task flows, usability
• Systems: components, patterns, design tokens, accessibility (WCAG)
• Prototyping: test ideas fast; learn to fake it before you build it
• Storytelling: explain decisions with evidence and outcomes

I practice these on tiny, repeatable drills: redesign a form, rewrite a microcopy string, refine a button set, rebuild a card component, improve an empty-state message. Ten minutes a day beats a weekend cram.

Step 3: Tools (learn just enough to ship)

You don’t need every tool. Pick one per category and start building.

• Design: Figma (primary), plus FigJam for flows/notes
• Prototype: Figma interactive components; add ProtoPie/Principle for motion if needed
• Assets: Illustrator/Photoshop (or Affinity), Spline or Blender for simple 3D
• Handoff: Figma dev mode, design tokens basics
• Versioning: Figma libraries; optional: GitHub for front-end projects
• Research: Google Forms, Typeform, Lookback (or simple Zoom + notes)

Pro tip: create a personal Figma library (buttons, inputs, type scales, color tokens). You’ll reuse it across projects and ship faster.

Step 4: Build proof, not noise (projects that actually matter)

A great portfolio is not 12 screens with gradients. It’s 3–5 projects that show you solved a real problem, learned something, and moved a metric.

Kickoff project ideas you can do in 1–2 weeks

• Onboarding fix: reduce friction for an app you use—measure completion rate
• Accessibility refresh: improve contrast, focus order, and copy for a flow
• Checkout redesign: simplify steps; compare time to complete before/after
• Empty state & error states: add guidance, examples, and recovery paths
• Design-system slice: build a small component library with tokens and docs

Each project needs a simple arc: Problem → Exploration → Solution → Evidence (usability notes, before/after, small metric).

Step 5: Ship a lean portfolio (what I actually put inside)

Think of your portfolio as a product with one goal: make it easy to say “interview them.”

• Home: one-line positioning (“I design clear, accessible B2B workflows”).
• 3–5 case studies: each with a headline outcome (“Cut task time by 32%”).
• About: photo, story, your values, the tools you use.
• Links: resume/CV, LinkedIn, email, optional GitHub/Dribbble.
• Contact: one obvious CTA.

Case study skeleton (copy/paste)

1. Context: who/what/constraints
2. Problem: why it matters (user + business)
3. Role & timeline: what you did
4. Process: research → flows → iterations → final
5. Outcomes: usability wins, time saved, conversion lift, or lessons learned
6. Reflection: what you’d do next (shows maturity)

Keep it skimmable: subheads, short paragraphs, and alt text for images.

Step 6: Understand the roles and pick projects that fit

Step 7: My 90-day starter plan (what I’d do if I were you)

Month 1 — Foundations & one quick win

• Week 1: UI/UX basics (hierarchy, spacing, type, color); rebuild a simple screen.
• Week 2: Task flows + wireframes; redesign a sign-up.
• Week 3: Components + tokens; create a mini library.
• Week 4: Project #1 (onboarding improvement) → publish a short case.

Month 2 — Research & systems

• Week 5: Research basics; run 3 quick interviews about a daily app.
• Week 6: Prototype + test (5 users is enough for direction).
• Week 7: Project #2 (form accessibility + microcopy).
• Week 8: Write both case studies; tighten visuals; add metrics.

Month 3 — Portfolio & pipeline

• Week 9: Project #3 (design-system slice for buttons/inputs/type).
• Week 10: Publish portfolio (home, about, 3 cases).
• Week 11: Outreach: 30 messages to designers/recruiters (ask for feedback, not a job).
• Week 12: Apply intentionally (10 roles/week) + keep iterating one project.

This plan compounds: fundamentals → evidence → visibility.

Step 8: Network without being weird

• Comment with value on posts: add an example, a reference, or a small test result.
• Share WIP weekly: a component, a comparison, or a lesson you learned.
• Ask for feedback from 3 people per project (and credit them).
• Join critique calls (Discord, Slack, local meetups) and repay every critique with one you give.

Ten thoughtful interactions per week beats a hundred cold DMs.

Step 9: Resume, LinkedIn, and applying (how I do it fast)

Resume (one page)

• Top: role/title you’re going for.
• Bullet points: impact > tasks (“Reduced error rate 18% by simplifying form”).
• Skills: tools + methods (research, tokens, accessibility).
• Projects: link to 2–3 case studies.

LinkedIn

• Headline with focus (“Junior Product Designer | Accessible workflows”).
• About: your story + what you’re learning now + what you want next.
• Featured: portfolio + one best case study.

Applying

• Don’t spray and pray. Customize 10 quality applications/week.
• Add a 3-sentence note: the user problem you love solving at their company, a quick idea, and a link to a relevant case.

Step 10: Interviews, whiteboards, and take-homes (how I prep)

• Product sense: practice structuring: goal → users → constraints → flows → risks.
• Critique: talk through tradeoffs, not taste (“We gain clarity but lose scan speed”).
• Whiteboard: narrate your thinking, ask clarifying questions, sketch lo-fi.
• Take-home: timebox, write assumptions, deliver a narrative (not just pretty screens).
• Reverse-interview: ask about metrics, design-dev workflow, accessibility standards, and design system maturity.

Remember: they’re assessing collaboration as much as visuals.

Step 11: Junior → Mid → Senior (what actually changes)

• Junior: learns fast, ships with guidance, asks good questions.
• Mid: owns a feature end-to-end, coordinates with PM/dev, tracks outcomes.
• Senior: defines problems, mentors others, shapes systems, improves processes.

Your leap from junior to mid happens when you own outcomes, not when your screens look the fanciest.

Step 12: Money, markets, and location

• Comp varies by market. Remote helps, but time-zone overlap and communication matter.
• Freelance? Productized services help: “Form audit in 48 hours,” “Onboarding teardown,” “Design-system slice.” Fixed scope, clear deliverable.
• Multiple income streams: templates, audits, workshops, mentoring—after you’ve built expertise doing the work.

Step 13: Common pitfalls (I’ve made them all)

• Pretty screens, unclear problems. Fix: lead with outcomes and evidence.
• Too many tools, not enough reps. Fix: limit tools; do daily drills.
• Portfolio bloat. Fix: 3–5 case studies, each with a headline outcome.
• Avoiding feedback. Fix: seek critique early; iterate in public.
• No metrics. Fix: measure something simple—time to complete, errors, clicks.

Step 14: A simple weekly rhythm (you can steal this)

• Mon: 60-min fundamentals drill (type, spacing, tokens).
• Tue: Case study writing (300 words) + one figure/diagram.
• Wed: Project work (prototype or usability test).
• Thu: Publish a WIP post; ask for one critique.
• Fri: Apply to 10 roles or reach out to 10 humans with value.
• Sat (optional): Explore a motion/interaction micro-interaction.
• Sun: Review: what moved the needle? Plan the next week.

Starter resource list (keep it lean)

• Design: NN/g (usability basics), Material/Apple HIG (patterns), WCAG quick refs
• Figma: official tutorials + “Auto Layout,” “Variants,” “Design tokens”
• Research: Just Enough Research (book), YouTube usability study examples
• Writing: Nicely Said (UX writing), Hemingway habits (plain language)
• Motion: Lottie/After Effects basics; ProtoPie/Principle demos

Final Thoughts

If you’re wondering how to build a career in design, here’s my bottom line: pick a lane for 90 days, practice fundamentals daily, ship three small projects with clear outcomes, and share your learning in public. That’s it. You don’t need permission. You don’t need perfect tools. You just need proof that you can find a problem, make a thing, and explain why it works.