Become a job-ready
UI/UX designer in 60 days

TheoryUI (User Interface) is everything you see and touch — colors, typography, buttons, icons, spacing. UX (User Experience) is everything you feel and do — how easy it is to complete a task, how many steps checkout takes, whether you get lost. A beautiful app with confusing flows has good UI and bad UX; an ugly app that works flawlessly has bad UI and good UX. Great products need both, which is why Indian companies mostly hire combined "UI/UX Designer" or "Product Designer" roles.

• UI Designer — visual craft: layouts, colors, components, design systems.
• UX Designer — flows, research, wireframes, usability testing.
• Product Designer — both + business thinking (the most-hired title in Indian startups).
• UX Researcher — interviews, testing, insights (specialist role, growing in India).

WatchFlux Academy — UI vs UX, what's the difference? · Malewicz — UI vs UX explained

PracticeOpen Swiggy and Zomato side by side. Write 5 UI differences (colors, buttons, fonts) and 5 UX differences (checkout steps, search behaviour, onboarding). Then create your free Notion "Design Journal" and write 200 words on why you're becoming a designer.

ResourcesIxDF: What is UX Design? · NN/g: The Definition of UX

TheoryDesign Thinking is a repeatable 5-stage process for solving problems from the user's side, popularised by IDEO and Stanford d.school. Empathize (understand real users), Define (frame the exact problem), Ideate (generate many solutions), Prototype (build a cheap testable version), Test (watch real users, learn, loop back). It's non-linear — you'll jump back and forth. Every interview case-study question ("walk me through your process") expects you to narrate some version of this.

• Fall in love with the problem, not your solution.
• Define stage output = a sharp problem statement, not a feature list.
• Prototype cheap and early — paper counts.
• Testing isn't the end; it feeds back into Define and Ideate.

WatchAJ&Smart — Design Thinking explained · AJ&Smart — Design Sprint walkthrough

PracticePick a daily-life problem (e.g., "college students waste food in mess"). Run a 30-minute mini design-thinking sprint on paper. Document it in your journal with photos, then ask Claude to critique your problem definition.

ResourcesIxDF: 5 Stages of Design Thinking · NN/g: Design Thinking 101

TheoryDesign is applied psychology. Jakob's Law: users spend most of their time on OTHER apps, so they expect yours to work the same way — that's why every Indian app puts the cart icon top-right and navigation at the bottom. Hick's Law: decision time grows with the number of choices — more menu options = slower, more stressful decisions. Fitts's Law: the time to tap a target depends on its size and distance — primary buttons are big and thumb-reachable; tiny close buttons in corners are hard.

• Jakob's Law is why "innovative" navigation usually fails — familiarity wins.
• Hick's Law is why Swiggy shows categories, not 500 restaurants at once.
• Fitts's Law is why "Pay" buttons are full-width at the bottom of the screen (thumb zone).

WatchMalewicz — UX psychology every designer needs · NN/g — Jakob's Law explained

PracticeFind one example of each law in PhonePe or Google Pay. Screenshot and annotate them with your phone's markup tool, then add "3 Laws I found in Indian apps" to your journal.

ResourcesLaws of UX (read Jakob's, Hick's, Fitts's) · Growth.design — psychology case studies

TheoryFour more psychology weapons. Miller's Law: working memory holds ~7±2 items — that's why phone numbers are chunked ("98765 43210") and onboarding asks 2-3 things per screen. Aesthetic-Usability Effect: beautiful designs are perceived as easier to use — users forgive small flaws in gorgeous apps. Von Restorff Effect: the item that stands out gets remembered — why the "recommended" pricing plan is highlighted. Peak-End Rule: people judge an experience by its most intense moment and its ending — why CRED celebrates payment success with confetti.

• Chunk everything: forms, lists, onboarding steps, card numbers.
• Make ONE thing stand out per screen — highlight everything = highlight nothing.
• Design your flow's ending deliberately: success states are emotional real estate.

WatchGrowth.design — UX psychology case studies · NN/g — Peak-End Rule in UX

PracticeAnalyze CRED's payment success screen — which effects create delight? Analyze Zepto's 10-minute promise — which biases does it trigger? Build an 8-row "Law → Indian app example" table in Notion and post one insight with #60DaysOfDesign.

ResourcesLaws of UX (remaining laws) · Growth.design: 101 cognitive biases

Theory95% of UI is text, so typography IS interface design. Learn font categories: serif (traditional, editorial — Times), sans-serif (modern, screens — Inter, Poppins), display (personality, headlines only). A type scale is a fixed set of sizes (e.g., 12/14/16/20/24/32) — never invent random sizes per screen. Line height for body text: 1.4–1.6× the font size. Body text on mobile: 16px minimum. Pair one workhorse sans for body with at most one distinctive heading font.

• Max 2 typefaces per product. Hierarchy comes from size + weight, not more fonts.
• Line length sweet spot: 45–75 characters per line.
• Letter spacing: slightly negative for big headings, slightly positive for ALL-CAPS labels.
• Indian apps: Swiggy & Zomato use custom sans fonts; most startups use Inter/Poppins.

WatchThe Futur — Typography principles · DesignCourse — Typography in UI

PracticeOn Google Fonts, pick 3 heading+body pairings. Then design the same quote 3 times with different pairings and hierarchy — which reads best and why? Note it in your journal.

ResourcesGoogle Fonts Knowledge (free course) · Butterick's Practical Typography

TheoryColor is emotion + function. Learn the HSB model (Hue = which color, Saturation = intensity, Brightness = lightness) — it's how designers think, not RGB. The 60-30-10 rule: 60% dominant neutral, 30% secondary, 10% accent — this is why good UIs feel calm, not rainbow. Semantic colors carry fixed meaning: green = success, red = error/danger, orange/yellow = warning, blue = info. Accessibility: WCAG AA requires 4.5:1 contrast for body text, 3:1 for large text — a legal requirement in many markets and an interview favorite.

• Build palettes in HSB: keep hue, vary saturation/brightness for shades.
• Neutrals do the heavy lifting — accents are for actions and highlights only.
• Never rely on color alone (colorblind users): pair with icons/labels.

WatchThe Futur — Color theory for designers · DesignCourse — Color in UI design

PracticeGenerate 3 palettes on Coolors: fintech (trust), food (appetite), health (calm). Check each on WebAIM. Then decode PhonePe (purple = trust + premium) vs Zomato (red = appetite + urgency) in your journal.

ResourcesCoolors — palette generator · WebAIM Contrast Checker

TheorySpacing is the invisible skill that separates amateur from professional UI. The 8-point system: every margin, padding, and gap is a multiple of 8 (or 4 for fine detail) — 8, 16, 24, 32, 48. This creates rhythm the eye feels even if users can't name it. Grids: mobile uses 4 columns, tablet 8, desktop 12 — content aligns to columns, never floats randomly. Visual hierarchy = controlling what gets seen first, second, third using size, weight, color, and position. Related items sit close (proximity); generous white space isn't wasted space, it's focus.

• When a design "feels off", check spacing consistency first — it usually is.
• More space around an element = more importance.
• Every screen should have ONE clear primary action.

WatchMalewicz — 8pt grid & spacing · Jesse Showalter — Visual hierarchy

PracticeScreenshot Groww's stock detail page. Mark up its grid, spacing rhythm, and hierarchy order. Then sketch the same screen twice — once with bad spacing, once with good — and note 5 rules you followed.

ResourcesFigma: Space, Grids and Layouts · Law of Proximity

TheoryGestalt psychology explains how the brain groups what it sees — before conscious thought. Proximity: things close together feel related (label near its input field). Similarity: things that look alike feel related (all links same color). Common Region: things inside a boundary feel grouped (cards!). Closure: the brain completes incomplete shapes (loading spinners). Continuity: eyes follow lines and paths (horizontal scroll hints). Figure-Ground: we separate foreground from background (modals dimming the page behind).

• Cards are Common Region — the single most-used Gestalt trick in modern UI.
• If elements feel unrelated, move them closer OR make them look similar.
• A modal + dimmed backdrop = Figure-Ground doing the focus work.

WatchNN/g — Gestalt principles series · Flux Academy — Gestalt in web design

PracticeOpen Meesho's product listing and identify 4 Gestalt principles at work. Then build your one-page "Design Principles Cheat Sheet" in Notion covering Days 3–8 — you'll revise it before every interview.

ResourcesNN/g: Gestalt Principles series · IxDF: Gestalt Principles

TheoryA teardown is a structured critique of a real product — the fastest way to convert theory into a designer's eye. The professional method: (1) pick ONE specific flow, not the whole app; (2) screenshot every single screen and state; (3) evaluate each against principles you can NAME (not "I don't like it" but "this violates Hick's Law because…"); (4) suggest improvements with reasoning. Teardowns are also a common interview exercise — you're literally practicing an interview skill today.

• Critique with vocabulary: name the law/principle behind every observation.
• Note what's done WELL too — recognizing good decisions is half the skill.
• Always suggest a fix — critique without alternatives is just complaining.

WatchAnsh Mehra — Indian app UX breakdowns · Growth.design — product teardowns

PracticeFull teardown of Zomato's onboarding + first-order flow (8–10 screens) using everything from Days 1–8. Publish it as a Notion page or LinkedIn carousel: "I analyzed Zomato's onboarding as a design beginner — here's what I found." Your first public artifact!

ResourcesGrowth.design teardowns (steal the format) · Mobbin — reference screens

TheorySpaced repetition day. Revise your cheat sheet covering: UI vs UX, design thinking stages, Jakob's/Hick's/Fitts's/Miller's laws, Aesthetic-Usability, Von Restorff, Peak-End, typography scale & pairing, HSB + 60-30-10 + WCAG contrast, 8pt spacing, visual hierarchy, and all 6 Gestalt principles. Then ask Claude: "Quiz me with 15 questions on UX laws, typography, color theory, and Gestalt. Grade my answers strictly."

• Teaching = learning: explain 3 concepts aloud to a friend (or to Claude).
• Below 70% on the quiz? Revisit weak topics today, not "later".
• Above 70%? Browse Mobbin 30 min and name principles in 10 screens.

WatchMalewicz — UI fundamentals recap

PracticeTake the Claude quiz, fix weak spots, then write your "Week 1–2 reflection" post on LinkedIn: what surprised you most about design? Tag #60DaysOfDesign.

ResourcesUX Collective — 1 article/day habit · Claude (your AI quiz master)

TheoryFigma is THE tool — every Indian design team uses it, and it's free. Learn the anatomy: canvas (infinite workspace), frames (screens/containers — they have their own size, constraints, and layout; always prefer frames over groups), layers panel (left), properties panel (right), pages (organize work). Master the core shortcuts on day one: F frame, R rectangle, O oval, T text, K scale, Cmd/Ctrl+D duplicate, Shift+A auto layout (tomorrow's superpower).

• Frames ≠ Groups: frames clip content, hold constraints & layout. Use frames.
• Name your layers from day one — messy files = messy designer signal.
• Speed comes from shortcuts, not the toolbar. Force yourself to use them.

WatchFigma official — Figma for Beginners playlist · Jesse Showalter — Figma for beginners

PracticeCreate a mobile frame (390×844). Add shapes, text, images; practice align, distribute, and constraints for 45 minutes. Then recreate a clean business card on an 8pt grid — name, role, phone.

ResourcesFigma official beginner course

TheoryAuto layout is Figma's most important feature — it makes elements behave like real UI: buttons grow with their labels, lists reflow when items are added, cards adapt when resized. Learn: direction (horizontal/vertical), gap (space between children), padding (space inside), and the three sizing modes — Hug (shrink to fit content), Fill (stretch to fill parent), Fixed (locked size). Real screens are auto layouts nested inside auto layouts, 4–6 levels deep. Interviewers literally watch whether you use auto layout during live exercises.

• Button = horizontal auto layout, hug × hug, padding 12×24, gap 8.
• Text inside buttons/cards should usually be Fill-width for clean wrapping.
• Shift+A wraps any selection in auto layout instantly.

WatchFigma official — Auto layout explained · Mizko — Auto layout deep dive

PracticeBuild with auto layout only: a button (with icon), a chip, a list row (avatar + text + arrow), a card. Then build a Swiggy-style restaurant card (image, name, rating, cuisine, delivery time) that stretches cleanly when resized.

ResourcesAuto layout docs

TheoryComponents are reusable building blocks — design a button once, use it 100 times. Edit the main component and every instance updates automatically; that's how teams keep 200 screens consistent. Overrides let each instance change text/images while inheriting structure. Variants bundle states of the same component (default/hover/pressed/disabled, primary/secondary). Component properties make instances configurable: boolean (show/hide icon), text (label), instance swap (change icon).

• Rule: if you use it twice, make it a component.
• Variants = same component, different states. Not different components.
• Never "detach instance" casually — you lose the link to updates.

WatchFigma official — Components & variants · Mizko — Component properties masterclass

PracticeConvert yesterday's button into a component with 4 variants (primary/secondary × default/disabled) + a boolean icon property. Then build a mini set: input field (default/focus/error), checkbox, and toggle.

ResourcesGuide to components

TheoryStyles and variables are how one designer keeps 100 screens consistent. Color styles name your colors ("Primary/500", "Text/Muted") so changing one updates everywhere. Text styles lock your type scale ("H1", "Body", "Caption"). Effect styles standardize shadows. Variables (design tokens) go further — they hold values (colors, numbers, strings) that can switch by mode (light/dark theme!) and bind to spacing and radii too. Also set up a 4-column mobile layout grid on your frames.

• Name semantically: "Surface/Card", not "Grey-2" — meaning survives rebrands.
• Variables > styles for anything that changes by theme or breakpoint.
• Never use a raw hex twice — if it repeats, it's a style/variable.

WatchFigma official — Variables explained · DesignCourse — Design tokens in Figma

PracticeCreate your mini style guide: 8 color styles (primary, surface, text, semantic), 6 text styles (H1→caption), 2 shadows. Apply them to your Day 13 components, then document everything on one Figma page like a professional handoff.

ResourcesGuide to variables

TheoryCopywork is how artists have trained for centuries — and how designers train their eye. By rebuilding a professional screen pixel-by-pixel, you're forced to notice decisions you'd otherwise scroll past: exact paddings, font sizes, radius values, shadow softness, color layering. CRED is the perfect subject: its "premium dark + huge spacing" style is deliberate and consistent. Ethics note: copywork is for learning only — never publish it as your own design (credit the app if you share your study).

• Measure obsessively: eyeball first, then check — that gap is training.
• Notice CRED's ratios: padding is often 1.5–2× what beginners use.
• Match shadows exactly — beginners always make them too dark and hard.

WatchMizko — Recreating real UIs in Figma · Saptarshi Prakash — design breakdowns

PracticeScreenshot 2 CRED screens (or grab from Mobbin). Recreate them in Figma as precisely as possible — fonts, spacing, radii, shadows. Place your recreation beside the original and list 5 design decisions you now understand.

ResourcesMobbin — real app screenshots · Figma Community

TheoryYesterday was premium minimalism; today is information density. Swiggy's home screen packs search, location, offers, categories, filters, and restaurant cards — yet doesn't feel chaotic. Why? A strict grid, consistent card anatomy, disciplined spacing rhythm, and clear section hierarchy. Dense-but-clean is the hardest UI skill and the most common in real Indian product work — most apps are content-heavy, not minimal.

• Density works when SECTIONS are clearly separated — spacing between sections > spacing within.
• Every card follows identical internal anatomy — that repetition creates calm.
• Use real content (Unsplash food pics, real restaurant names) — lorem ipsum hides layout problems.

WatchJesse Showalter — App UI rebuild sessions · DesignCourse — Food app UI in Figma

PracticeRecreate Swiggy's home screen with auto layout + your components (Unsplash plugin for food images, Iconify for icons). Post both copywork studies on LinkedIn: "Day 15–16: I rebuilt CRED & Swiggy screens to train my eye" — credit the apps.

ResourcesUnsplash plugin · Iconify plugin

TheoryPrototypes turn static screens into clickable experiences — essential for testing (Day 31) and impressive in portfolios. Learn the model: trigger (tap, drag, hover, after-delay) → action (navigate to, open overlay, scroll to, go back) → animation (instant, dissolve, move in, push, smart animate). Smart animate is the magic: it interpolates between two frames by matching layer names — position, size, opacity morph smoothly. Overlays handle popups, bottom sheets, and toasts without duplicating whole screens.

• Smart animate matches layers BY NAME — identical names across frames = smooth motion.
• Bottom sheets & popups = overlays, not new screens.
• Standard durations: 200–300ms. Slower feels laggy, faster feels jumpy.

WatchFigma official — Prototyping basics · Mizko — Smart animate tricks

PracticeConnect your Swiggy screens: tap restaurant card → detail screen → "add to cart" overlay. Add smart animate to one micro-interaction. Screen-record the preview for your journal — your first working prototype!

ResourcesPrototyping guide

TheoryToday you graduate from copying to creating. First study the patterns: Indian apps use phone + OTP first (not email — email is a Western pattern), because phone numbers are identity in India (UPI, WhatsApp, Aadhaar-linked). Progressive disclosure: ask the minimum upfront (phone), collect the rest later (name, photo) — every extra field costs signups. Social login (Google) is a common secondary option. Auto-read OTP, clear resend timers, and helpful error states separate good onboarding from rage-quits.

• Welcome screen = one clear value proposition + one primary CTA.
• OTP screen essentials: auto-focus, big digits, resend timer, edit-number link.
• Every field you delay = higher conversion. Ask: "do we need this NOW?"

WatchAnsh Mehra — Onboarding UX · DesignCourse — Designing signup flows

PracticeDesign a 3-screen sign-up flow (welcome → phone/OTP → profile) for an imaginary UPI app — from scratch, using your own style guide. Prototype it, then paste screenshots to Claude: "critique this onboarding against UX best practices for Indian users".

ResourcesPage Flows — flow recordings · Mobbin onboarding patterns

TheoryProfessional speed comes from workflow, not talent. Figma Community is a goldmine: free UI kits, design systems, and files from real teams — duplicate them to study how pros organize pages, name layers, and structure components. Essential plugins: Iconify (200k+ icons), Unsplash (photos), Content Reel (realistic names/avatars/numbers), Stark (accessibility contrast checks), Remove BG. Learn to fill a screen with realistic content in minutes instead of hours.

• Study community files for ORGANIZATION, don't pass them off as your work.
• Realistic content exposes layout problems that lorem ipsum hides.
• Build your personal "starter file" with styles + components you reuse.

WatchMizko — Best Figma plugins · Jesse Showalter — Figma workflow tips

PracticeDuplicate a top community UI kit and study its organization. Install the 5 plugins. Then rebuild one Day 16 screen in half the time using plugins + shortcuts — note your speed gain.

ResourcesFigma Community · Content Reel plugin

TheoryGraduation test — pure execution. Before you start, review the professional checklist: styles set up first, components for anything repeated, auto layout on every frame, real content everywhere, consistent 8pt spacing, one primary action per screen. Time-box each screen to ~40 minutes. Done beats perfect — you'll iterate after feedback.

• Set up styles + core components BEFORE designing screens (30 min investment).
• Design mobile-first at 390×844.
• Prototype the full happy path: open app → add habit → mark done → view stats.

WatchDesignCourse — Full app UI start to finish

PracticeDesign the 5-screen habit-tracker (home, add habit, detail, stats, profile) with your style guide, components, and auto layout throughout. Prototype all 5. Share the link on LinkedIn + design communities and save every piece of feedback in your journal.

ResourcesFigma Community (inspiration only) · Dribbble habit tracker shots

TheoryResearch is what separates designers from decorators. Two axes to master: Qualitative vs Quantitative — qual answers "why" (interviews, field studies, 5–8 people), quant answers "how many" (surveys, analytics, hundreds of users). Attitudinal vs Behavioural — attitudinal is what people SAY (interviews, surveys), behavioural is what people DO (usability tests, analytics). The famous trap: users say one thing and do another — so never rely on attitudinal data alone for behaviour questions.

• Interviews = qual + attitudinal. Usability tests = qual + behavioural.
• Surveys = quant + attitudinal. Analytics = quant + behavioural.
• Fresher projects need just 2 methods done well — usually interviews + usability tests.

WatchNN/g — UX research methods · AJ&Smart — User research for beginners

PracticeChoose your capstone project — a problem you'll take from research to hi-fi design. Ideas: mess-food ordering for hostels, second-hand book exchange, kirana delivery, college event discovery. Write the problem statement (1 paragraph) + which 2 research methods you'll use and why.

ResourcesNN/g: Which UX Research Method · IxDF: User Research (free articles)

TheoryInterviewing is a craft: bad questions produce polite lies, good questions produce stories. Rules: (1) Ask about the PAST, not the hypothetical future — "Tell me about the last time you ordered mess food" beats "Would you use a mess-food app?" (people say yes to be nice). (2) Never lead — "How was that experience?" not "Wasn't that frustrating?" (3) Use the 5 Whys to dig from surface complaints to root causes. (4) Listen for pain points and workarounds, not feature requests — users are experts in their problems, not in solutions.

• Silence is a tool — wait 3 seconds after answers; people fill it with gold.
• Workarounds (Excel sheets, WhatsApp hacks) = strongest evidence of real problems.
• Record with permission, or take timestamped notes.

WatchNN/g — User interviews · AJ&Smart — Interview techniques

PracticeWrite a 10-question interview script + Google Form survey for your capstone. Have Claude red-team them for bias. Then interview 3 real people (friends/family count!) and share the survey in 2 WhatsApp groups.

ResourcesNN/g: User Interviews 101

TheoryA persona is a composite character built from RESEARCH DATA that keeps your team designing for real users instead of themselves. Useful persona contents: goals (what they're trying to achieve), frustrations (from actual interview quotes), behaviours (how they currently solve the problem), context (device, connectivity, time pressure — crucial in India: shared devices, patchy networks, regional languages). Decorative details (favorite color, zodiac 🙅) waste space. An empathy map organizes one user's world into four quadrants: Says / Thinks / Does / Feels — great for spotting say-do gaps.

• Persona = synthesized from interviews. Invented personas = fiction, not research.
• 2 personas max for a student project — primary and secondary.
• Every persona claim should trace back to something a real interviewee said/did.

WatchNN/g — Personas explained · CareerFoundry — Creating personas

PracticeFrom your interviews, build 2 personas + 1 empathy map in FigJam. Add them to your capstone file, then ask Claude: "What assumptions am I making about these users?"

ResourcesNN/g: Personas 101 · FigJam (free whiteboard)

TheoryNow convert raw research into design direction. "How Might We" (HMW) statements reframe problems as opportunities: insight "students skip mess food because menus are unpredictable" → "HMW help students know what's being served before they walk over?" The framing matters: too broad ("HMW fix food") gives no direction; too narrow ("HMW add a menu screen") smuggles in a solution. Competitive analysis: map direct competitors (same solution) and indirect (same problem, different solution — the mess notice board is your competitor too!). Build a feature matrix to find gaps nobody serves.

• HMW sweet spot: wide enough for multiple solutions, narrow enough to focus.
• Indirect competitors reveal what users ACTUALLY do today — study them hardest.
• The gap in the feature matrix = your opportunity statement.

WatchAJ&Smart — How Might We method · NN/g — Competitive evaluations

PracticeWrite 5 HMW statements for your capstone; pick the strongest. Analyze 3 competitors in a feature matrix. Then produce your one-page research summary: problem → insights (with quotes) → HMW → opportunity. This is Section 1 of your case study.

ResourcesNN/g: How Might We Questions · NN/g: Competitive Evaluations

TheoryInformation Architecture (IA) is organizing content so users find things without thinking. Core tools: sitemaps (the tree of all screens), navigation patterns (bottom tab bar = 3–5 top destinations, the mobile standard; hamburger menus hide things and hurt discovery), and card sorting (give users your content on cards, watch how THEY group it — open sort lets them name groups, closed sort uses your categories). Depth vs breadth: Amazon needs deep category trees (millions of products); Blinkit stays flat (speed matters more than browsing).

• Users' mental categories ≠ your org chart. Card sorting reveals theirs.
• Bottom tab bar: 3–5 items max, always visible, thumb-friendly.
• If a feature is buried 4 taps deep, it doesn't exist for most users.

WatchNN/g — Information architecture · CareerFoundry — Card sorting

PracticeList every capstone feature/screen on FigJam stickies. Run a card sort with a friend, then draw your sitemap. Bonus: sketch Amazon India's IA vs Blinkit's — why deep vs flat?

ResourcesNN/g: IA Study Guide · IxDF: Information Architecture

TheoryA user flow maps every step and decision between a user's goal and its completion. Notation: rectangle = screen/action, diamond = decision point (logged in? balance sufficient?), arrows = direction. The happy path is when everything goes right — beginners design only this. Professionals map edge cases: wrong OTP, insufficient balance, no internet, empty states, server errors. In fintech (PhonePe, Rupeezy), edge-case handling IS the product — money + confusion = lost trust.

• Every diamond needs ALL its exits designed — yes AND no paths.
• Minimum edge-case set: error, empty, loading, offline.
• Flows before wireframes — structure before screens.

WatchFlux Academy — User flows · NN/g — Journeys vs flows

PracticeMap your capstone's 2 core task flows in FigJam with 3+ edge cases each. Then map PhonePe's "send money" flow from memory, verify in the app — what did you miss? (Wrong UPI PIN? New payee warning?)

ResourcesNN/g: User Journeys vs User Flows

TheoryLo-fi first is a discipline, not a shortcut. Why: (1) paper is cheap to change — you'll throw away 6 of 8 ideas, and that should cost minutes, not days; (2) rough sketches keep feedback on STRUCTURE — show someone a polished screen and they'll comment on colors; show a sketch and they'll comment on flow; (3) quantity beats quality early — Crazy 8s (fold paper into 8, sketch 8 layout ideas in 8 minutes) forces you past your first obvious idea. Conventions: box with X = image, horizontal lines = text, rectangle = button.

• Your first idea is usually everyone's first idea — Crazy 8s digs deeper.
• Ugly sketches get honest feedback; pretty mockups get compliments.
• Sketch UI patterns from memory — it reveals what you've actually internalized.

WatchAJ&Smart — Crazy 8s method · NN/g — Sketches & wireframes

PracticeCrazy 8s for your capstone's home screen — 8 ideas in 8 minutes, pick the best 2. Then sketch all core screens on paper, photograph them, add to your Figma file.

ResourcesNN/g: Sketches & Wireframes

TheoryDigital wireframes sit between paper sketches and hi-fi UI: precise enough to test, grey enough to keep feedback on structure. Fidelity ladder: sketch → lo-fi wireframe (greyscale boxes) → mid-fi (real content, still grey) → hi-fi (full visual design). Golden rule: use real-ish content even in wireframes — "Paneer Tikka — ₹249" not "Lorem ipsum" — because real content exposes layout problems (long names, big numbers, empty lists) that dummy text hides. Resist the urge to style: color comes on Day 41, and adding it now will anchor you.

• Greyscale only: black, white, 3 greys. No brand colors yet.
• Real content stress-tests the layout — try the LONGEST restaurant name you know.
• Wireframe every screen in your 2 core flows, including edge states.

WatchDesignCourse — Wireframing in Figma

PracticeTurn your paper sketches into 6–8 greyscale wireframes in Figma. Link them into a clickable lo-fi prototype covering your 2 core task flows.

ResourcesFigma: Wireframing guide · UX Collective wireframing articles

TheoryNielsen's 10 heuristics (1994, still the industry standard) are the most interview-quoted framework in UX. The 10: (1) Visibility of system status — loading spinners, progress bars; (2) Match with real world — familiar words, not jargon; (3) User control & freedom — undo, cancel, back; (4) Consistency & standards; (5) Error prevention — confirm before delete; (6) Recognition over recall — show options, don't make users remember; (7) Flexibility & efficiency — shortcuts for experts; (8) Aesthetic & minimalist design; (9) Help users recover from errors — clear messages with fixes; (10) Help & documentation.

• Memorize all 10 by NUMBER and name — interviewers reference them casually.
• #1, #3, #5, #9 cover most real-world app problems.
• "Recognition over recall" is why search shows recent queries.

WatchNN/g — official 10 heuristics video series

PracticeFor each heuristic, screenshot one good example and one violation from apps on your phone. Add a "Nielsen's 10 with Indian app examples" page to your cheat sheet.

ResourcesNN/g: 10 Usability Heuristics (the original)

TheoryA heuristic evaluation is an expert review against the 10 heuristics — no users needed (that's what distinguishes it from usability testing). The formal process: (1) define scope (one flow); (2) walk through screen by screen, noting every violation WITH its heuristic number; (3) rate severity 0–4: 0 = not a problem, 1 = cosmetic, 2 = minor, 3 = major (fix priority), 4 = catastrophic (blocks the task); (4) recommend a fix per issue. Output = a table: screen, issue, heuristic violated, severity, recommendation.

• Severity = frequency × impact × persistence. A rare cosmetic glitch ≠ a checkout blocker.
• Cite the heuristic number for every issue — that's what makes it professional.
• This exact exercise appears in real interview take-homes. You're rehearsing.

WatchNN/g — Heuristic evaluation walkthrough

PracticeRun a full heuristic evaluation of Meesho's search → product → checkout flow. Find 8+ issues with heuristic numbers, severity ratings, and fixes. Format as a mini report — this is portfolio material.

ResourcesNN/g: How to Conduct a Heuristic Evaluation

TheoryUsability testing = watching real people attempt real tasks on your design. NN/g's famous finding: 5 users uncover ~85% of usability problems — you don't need a lab or a budget. Method: write TASKS not instructions ("You're hungry, order dinner" — not "tap the search icon, then…"); ask users to think aloud; then shut up and watch. When they're stuck, DON'T help — the awkward silence is data. When they criticize, DON'T defend — you're testing the design, not your ego. Watch for: hesitations, wrong taps, backtracking, and the words they use.

• Task ≠ instruction: give the goal, never the steps.
• If you have to explain your design, the design failed the test.
• Note WHAT happened + WHERE + your interpretation separately.

WatchNN/g — Live usability test demo · AJ&Smart — Testing with 5 users

PracticeTest your lo-fi prototype with 3 people using 3 tasks. Log every hesitation, wrong tap, and confused expression. Summarize: what worked, top 5 issues, what you'll change — straight into your case study file.

ResourcesNN/g: Usability Testing 101

TheoryWords are interface. UX writing rules: (1) Clarity over cleverness — cute copy that confuses loses to boring copy that works; (2) Front-load keywords — users scan the first 2 words of everything; (3) Buttons state outcomes — "Pay ₹499" beats "Submit", "Save changes" beats "OK"; (4) Errors follow the formula: what happened + why (if useful) + how to fix — "Card declined — try another card or pay via UPI" vs "Error 402"; (5) Empty states teach — a blank screen is a chance to guide ("No orders yet. Hungry? Explore restaurants near you").

• Read every label aloud — if you wouldn't SAY it to a user, rewrite it.
• Zomato/CRED show personality in low-stakes moments, clarity in high-stakes ones.
• Never blame the user in error copy ("You entered wrong…" → "That PIN didn't match").

WatchNN/g — UX writing tips · Flux Academy — Writing for UX

PracticeFix your wireframes per Day 31 findings, then rewrite every label, button, error, and empty state with proper UX copy. Collect 5 great microcopy examples from Indian apps and 3 terrible ones — what's the difference?

ResourcesNN/g: UX Writing Study Guide · UX Writing Hub blog

TheoryWelcome to your differentiator. In 2026 hiring, AI-fluent designers command premium salaries — not because AI designs for them, but because they ship 3× faster with it. Map the stack: Claude/ChatGPT (thinking partner: research synthesis, critique, copy, interview prep), Figma AI (in-tool: rename layers, generate drafts, edit images), Adobe Firefly (imagery), Framer AI (live websites), Galileo AI (quick UI drafts). The core skill is prompting: Role + Context + Task + Format + Constraints. Weak prompts get generic outputs; specific prompts get usable ones.

• AI amplifies judgment — it can't replace knowing WHAT good looks like (Days 1–32!).
• Always give AI a role and context: "You're a design manager at a Bengaluru fintech…"
• Iterate: first output is a draft, not an answer. Push back, refine, combine.

WatchMizko — AI tools for designers · The Futur — AI in design workflows

PracticeWrite 5 design prompts in weak + strong versions ("give app ideas" vs "You're a senior product designer at a Bengaluru fintech. Suggest 5 onboarding improvements for first-time UPI users in tier-2 cities, with reasoning"). Start your Notion "Prompt Library" — it becomes a portfolio talking point.

ResourcesClaude · Anthropic Academy — free AI courses · Figma AI features guide

TheoryAI transforms the slowest part of research — synthesis. What AI does brilliantly: cluster interview notes into themes in minutes (vs hours of sticky notes), draft unbiased question guides, spot patterns across transcripts you'd miss, red-team your assumptions, simulate user perspectives for early gut-checks. What AI CANNOT do: observe real behaviour, feel real frustration, know your specific users' context. The professional workflow: AI does the first synthesis pass → you verify every claim against raw notes → you own the conclusions. Never present AI-only synthesis as research.

• Feed raw notes, ask for themes grouped by frequency + severity, with supporting quotes.
• Always ask: "What's a weak or missing part of this synthesis?" — AI critiques itself well.
• Simulated users are hypotheses, not data. Real users still required.

WatchNN/g — AI in UX research · AI research synthesis workflows

PracticeFeed your Day 22 interview notes to Claude: "Extract themes, pain points, and surprising insights; group by frequency and severity; cite quotes." Compare against your manual Day 24 synthesis — what did each miss? Then AI-generate a follow-up discussion guide and note every suggestion you rejected and why.

ResourcesNN/g articles on AI in UX · Claude for synthesis

TheoryAI is a copy machine — you are the editor-in-chief. Best uses: variation generation (10 headline options in seconds — humans anchor on their first idea, AI doesn't), tone shifting (formal → friendly → Hinglish for Indian audiences), systematic libraries (complete error-message sets for network/validation/payment in one prompt), and consistency checks (paste all your labels, ask for tone inconsistencies). The Day 32 rules still govern: clarity over cleverness, outcomes on buttons, blame-free errors. AI generates; your judgment — trained on those rules — selects and refines.

• Ask for 10, pick 1, hand-polish it. Never ship option #1 unedited.
• Give AI your voice guidelines in the prompt ("friendly, no jargon, Indian audience").
• Hinglish works for casual apps (Zomato-style), not for fintech trust moments.

WatchAI-assisted UX writing workflows

PracticeGenerate 10 onboarding-headline variations in 3 tones for your capstone. Build a full error-message library (network, validation, payment, empty states) with AI, hand-edit each, apply the best to your wireframes. Screenshot before/after for the case study.

ResourcesUX Writing Hub · NN/g UX Writing guide

TheoryAI UI generators (Galileo AI, Figma AI drafts) turn text prompts into screens in seconds. Their honest scorecard — strengths: instant layout exploration, breaking blank-canvas paralysis, quick stakeholder mockups; weaknesses: generic "AI look", broken spacing systems, no real components or design tokens, poor edge-case thinking, zero brand personality. The professional workflow: generate for IDEAS, then rebuild properly with your own design system. Companies pay designers who can DIRECT and REFINE AI output — not ones who paste it raw.

• AI output = moodboard for layout, never final artwork.
• Test yourself: can you articulate WHY your rebuild is better? That's the skill.
• Detailed prompts (screen type, sections, style, audience) beat one-liners.

WatchMizko — Figma AI in practice · Galileo AI generator walkthrough

PracticeGenerate your capstone's home screen with a free AI UI tool (Galileo AI / Figma AI). Rebuild it properly with your design system — better than the AI version. Post the side-by-side on LinkedIn: "I tested AI UI generators as a design learner — here's what they get right and wrong."

ResourcesGalileo AI (free tier) · Figma AI

TheoryAI imagery fills the gap freshers always hit: no budget for illustrators or stock. Learn the image-prompt anatomy: subject + style + mood + color + composition + aspect ratio — "flat illustration of a student ordering food on phone, warm orange palette, minimal, white background, 1:1". Consistency trick: reuse the exact style phrase across all images so your app's illustrations feel like one family. Free stack: Adobe Firefly (free credits, commercially safer) and ChatGPT's built-in image generation (same free account you already use for research). Midjourney is industry-loved but paid — concepts transfer 1:1 later.

• Lock a "style suffix" and append it to every prompt for visual consistency.
• Illustrations for empty states + onboarding; photos for content; icons stay from icon sets.
• Check usage rights before commercial use — Firefly is the safest free option.

WatchFirefly for designers · The Futur — AI imagery in design work

PracticeCreate your capstone moodboard: 8 AI images defining mood, color, and illustration style. Generate an app icon + 2 empty-state illustrations with a consistent style suffix. Save every prompt to your Prompt Library.

ResourcesAdobe Firefly · ChatGPT

TheoryToday you SHIP something live on the internet — a psychological milestone most freshers never cross. Framer is a design tool that publishes real websites: Figma-like canvas, AI page generation, sections, and responsive breakpoints (desktop/tablet/mobile layouts). Landing page anatomy: hero (value proposition + CTA above the fold), social proof, features as benefits, single conversion goal. Free plan publishes to a framer.app subdomain. Side bonus: landing pages are a freelance income skill by themselves — Indian small businesses pay ₹10–50k per page.

• One page, one goal, one primary CTA — repeated 2-3 times down the page.
• Write the headline as user benefit, not feature list ("Never miss mess dinner again").
• Check all 3 breakpoints before publishing — mobile first, it's most of your traffic.

WatchFramer Academy (official free lessons) · Flux Academy — Landing pages in Framer

PracticeGenerate a landing page for your capstone with Framer AI, customize typography/colors/copy to your brand, verify all 3 breakpoints, and publish live. Share the link — you've shipped!

ResourcesFramer (free plan) · Land-book — landing page inspiration

TheoryA design system is a product's design language made reusable: tokens + components + patterns + documentation. Atomic design (Brad Frost's model): atoms (colors, icons, buttons) combine into molecules (search bar = input + button), which form organisms (header = logo + nav + search), which build templates and screens. Design tokens are named decisions ("primary-500", "spacing-md") stored once, used everywhere — they power theming (light/dark) and platform consistency. Why it matters: Swiggy-scale teams have 30+ designers shipping daily; without a system, the product fractures in weeks.

• Study how Material 3 structures tokens: primitive → semantic → component-level.
• Same component, different philosophy: compare Material's button vs Apple HIG's.
• Systems thinking is a SENIOR signal — freshers who get it stand out immediately.

WatchFigma — Design systems explained · Brad Frost — Atomic design talk

PracticeExplore Material 3's components and token structure for an hour. Compare the button across Material, Apple HIG, and Atlassian. Journal entry: "10 things I learned from production design systems".

ResourcesMaterial Design 3 · Apple HIG · Atomic Design (free book)

TheoryBuild day. The token architecture you're implementing: primitives (raw values: orange-500 = #FF6321, grey-100…900) → semantic tokens that reference them (bg/default → grey-50, text/primary → grey-900, brand/primary → orange-500) → components that use only semantic tokens. Why the middle layer? When you rebrand or add dark mode, you remap semantics once — components never change. This 3-level structure is exactly how Material 3 and production teams work.

• Components must never reference primitives directly — semantics only.
• 10 core components: button, input, card, nav bar, tabs, chip, toast, checkbox, list row, modal.
• Every component: all states (default/hover/pressed/disabled/error where relevant).

WatchBuild a design system with Figma variables · Mizko — Design system build

PracticeBuild it: color & text variables in the 3-level structure, spacing scale, and 10 core components with variants. Document everything on one page like a developer handoff — this single page impresses interviewers.

Resourcesdesignsystems.com (Figma's free guides) · Figma: Design Systems 101

TheoryHi-fi day — everything converges: your wireframes (structure), moodboard (visual direction), and design system (components). The discipline: 20 minutes MAX of Mobbin inspiration (endless browsing is procrastination dressed as research), lock your visual direction, then execute using ONLY your design system components. If a screen needs something new, add it to the system first, then use it. This system-first workflow is exactly how you'll work at a real company.

• No detached instances — if the component doesn't fit, fix the component.
• Apply the 60-30-10 rule from Day 6 to every screen.
• Squint test: blur your eyes — the primary action should still be obvious.

WatchMalewicz — Wireframe to hi-fi

PracticeDesign hi-fi versions of your first 4 screens using only design system components. Post a wireframe → hi-fi comparison — these transformations perform brilliantly on LinkedIn and Instagram.

ResourcesMobbin · Dribbble (inspiration, with salt)

TheoryMicro-interactions are the small moments that make apps feel alive: button press states, loading skeletons (grey placeholder shapes beat spinners — they set layout expectations), pull-to-refresh, success animations, toast notifications. The rule: motion must have MEANING — it should confirm an action, show a relationship, or direct attention. Decoration-only animation ages badly. Today you also complete the full screen set: hi-fi versions of your empty, error, and loading states — the marks of a designer who thinks beyond the happy path.

• Skeleton screens > spinners for content loading.
• Animation durations: 200–300ms UI transitions, 400–600ms celebrations.
• Second usability test proves iteration — the strongest case-study evidence.

WatchSmart animate micro-interactions · Mizko — Advanced prototyping

PracticeFinish all screens (8–10 with empty/error/loading states). Build the polished clickable prototype. Then run your Day 31 tasks on it with 2 NEW users and log improvements — "tested twice, iterated twice" is a killer case-study line.

ResourcesFigma Community micro-interactions

TheoryA case study is a STORY about decisions, not a gallery of screens. The proven structure: Problem (who hurts, how much) → Research (what you did, who you talked to) → Insights (with real quotes) → Ideation (options you explored) → Design decisions (what you chose and WHY) → Testing (what broke, what you fixed) → Final designs → Impact & learnings. Brutal truth: recruiters spend ~2 minutes per portfolio, so headlines must tell the story alone — write section titles someone could skim and still understand your thinking.

• Screens show WHAT; case studies must show WHY. Why is what gets hired.
• Skim test: read only your headings — does the story still make sense?
• Include the messy middle: rejected ideas prove you explored.

WatchMizko — Case studies that get hired · Flux Academy — Portfolio case studies

PracticeStudy 3 great case studies from Bestfolios and growth.design — note how they show process, not just screens. Outline your capstone case study: every section heading + one line each.

ResourcesBestfolios · Growth.design case studies · Case Study Club

TheoryWriting day. Narrative techniques that work: (1) open with human cost — "Priya skips dinner twice a week because she can't tell if mess food is worth the walk" beats "I designed a food app"; (2) show forks in the road — "I considered tabs vs a feed; chose the feed because testing showed users browse, not search"; (3) admit failures — "My first checkout flow confused 3 of 3 testers" builds more trust than pretending perfection; (4) numbers where possible — 12 interviews, 5 usability tests, 8 iterations. Use AI to EDIT for clarity, never to write — interviewers smell generic AI case studies instantly.

• Your journal from Day 1 is now gold — quotes, screenshots, failures, all documented.
• Write long, then cut 30%. Brevity is respect for the reader's 2 minutes.
• Every section must answer: "What did YOU decide and why?"

WatchUX case study storytelling guides

PracticeWrite the full draft from your journal + research docs. AI for clarity editing only. Read it aloud, cut 30%.

ResourcesCase Study Club examples · UX Collective: How to write a UX case study

TheoryPresentation is a design project itself. The visual toolkit: device mockups (screens inside phone frames — instantly professional), before/after comparisons (wireframe vs hi-fi side by side), annotated screenshots (arrows explaining decisions), process photos (your paper sketches and FigJam boards — mess builds credibility!), and a strong cover image (this decides whether anyone clicks at all). Consistent formatting throughout: same background color for all mockup sections, same annotation style, same spacing.

• Cover image formula: app name + one-line problem + hero mockup.
• Show process artifacts — sketches, sticky notes, crossed-out ideas.
• Every image needs a caption. Uncaptioned images get skipped.

WatchCase study presentation techniques

PracticeCreate hero images and device mockups with free Figma Community kits or Shots.so. Design your cover image. Assemble text + visuals into your chosen format (Notion page or Figma slides).

ResourcesFree device mockups (Figma Community) · Shots.so — free mockup generator

TheoryPublishing day — from private work to public proof. Behance best practices: strong cover (Day 45), tags that recruiters search ("UI/UX", "Product Design", "Mobile App", "India"), a keyword-rich description (Behance is a search engine), and logical module flow. Multi-platform strategy: Behance for discovery, Notion for the deep-read version linked from your resume, LinkedIn carousel (8–10 slides in Figma) for reach — carousels are LinkedIn's highest-engagement format.

• Carousel slide 1 = hook ("I redesigned how 2000 hostel students eat dinner").
• Reply to EVERY comment — each reply is practice defending decisions.
• Post between 9–11am on weekdays for Indian LinkedIn reach.

WatchBehance publishing tips · Designing LinkedIn carousels

PracticePublish on Behance AND Notion. Design + post the LinkedIn carousel. Share in 3 design communities and respond to every comment.

ResourcesBehance · Notion (free portfolio hosting)

TheoryCase study #2 is a redesign — a different skill than 0-to-1: working within existing constraints, exactly like a junior designer's day job. The golden rule: never trash the original. "Zepto's cluttered home is bad design" is naive; "Zepto's dense home probably converts well — here's a targeted fix for first-time-user discovery" is professional. Assume the original team had reasons (metrics, tech constraints, deadlines). Ground your redesign in EVIDENCE: run a heuristic audit + test the actual app with 2 real users. Their struggles = your justification.

• Narrow beats broad: "I fixed IRCTC seat selection" > "I redesigned IRCTC".
• Evidence first: audit + user test BEFORE any redesigning.
• Humility reads as seniority in redesign case studies.

WatchRedesign case study walkthroughs

PracticePick one flow from an Indian app (Rupeezy watchlist, Groww SIP setup, IRCTC booking 😅). Run the heuristic audit + quick test with 2 people. Define the 2–3 focused problems you'll redesign.

ResourcesHeuristic evaluation guide · Mobbin for pattern research

TheoryExecution day with one hard constraint: stay inside the app's existing brand — its colors, fonts, and component style. Why? Because "redesign in your own style" is fan art; "improvement within the system" is the actual job. Junior designers spend their first year working inside someone else's design system. Demonstrating you can match an existing visual language while fixing real problems is the exact skill hiring managers look for.

• Rebuild their components first (30 min) — buttons, cards, nav in their style.
• Change ONLY what your evidence justifies. Every change traces to a finding.
• 4–6 screens, focused on your 2–3 defined problems.

WatchBefore/after redesign presentations

PracticeRedesign the flow (4–6 screens) inside the app's existing brand. Create before/after comparisons with annotations explaining each change and the principle behind it.

ResourcesFigma Community UI kits for speed

TheoryPlatform strategy: Dribbble = visibility (visual candy, tight crops, first-impression craft), Behance = depth (full case studies recruiters actually evaluate). A good Dribbble shot: one focused crop (not a full screen dump), bold color, maybe subtle motion (GIF), and a title that names the pattern ("Fintech onboarding — OTP flow"). Dribbble brings profile visits; your bio links them to Behance/portfolio where hiring decisions happen. Publishing case study #2 today means you now have TWO public case studies — genuinely more than 90% of fresher applicants.

• Crop tight: show the hero moment of a screen, not the whole screen.
• Bio must link to your full portfolio — Dribbble is the trailer, not the film.
• Consistent posting > one viral shot. Feed the algorithm weekly.

WatchDribbble shot best practices

PracticePublish case study #2 on Behance/Notion. Create 2 Dribbble shots from your best screens. Post LinkedIn carousel #2.

ResourcesDribbble · Behance

TheoryYour portfolio site is your #1 career asset. Structure (one page is enough): hero with clear positioning — "UI/UX Designer who ships with AI" beats "Hi, I'm Rahul, welcome to my page"; 2 case studies with strong covers (best one first); about with actual personality (your story, your city, what you're obsessed with); contact that's effortless (email + LinkedIn, no forms). Common fresher mistakes: 6 weak projects instead of 2 strong ones, hiding case studies behind clicks, no positioning statement, and slow image-heavy pages.

• Positioning formula: role + differentiator ("…who ships with AI" / "…for fintech").
• 2 great case studies > 6 mediocre ones. Quality signals judgment.
• Test on mobile — recruiters open portfolios from LinkedIn on phones.

WatchMizko — Portfolio sites that convert · Flux Academy — Portfolio reviews

PracticeBuild on Framer (you learned it Day 38) or Notion. Publish live. Then ask Claude to review your copy as "a design hiring manager at a Bengaluru startup — be brutal".

ResourcesFramer · Bestfolios for inspiration · Case Study Club

TheoryReceiving feedback is a learnable skill. The framework: signal vs noise — one person's opinion is data; three people saying the same thing is a pattern demanding action. When feedback stings, never defend ("but I meant…") — ask "what made you feel that?" to dig for the underlying issue. Categorize everything: fix-now (repeated + severe), backlog (valid, minor), discard (taste-only, contradicts your evidence). Designers who metabolize feedback fast grow 3× faster — and interviewers specifically probe "tell me about feedback you received."

• Count repetitions: 3+ mentions = pattern = fix it.
• Ask clarifying questions, never justify. Curiosity > ego.
• Keep a feedback log — it becomes your interview story bank.

WatchReceiving design critique well

PracticeShare your portfolio in 3+ communities and with designers you know (book an ADPList session!). Collect 10+ pieces of feedback, fix the top 3 repeated issues today, backlog the rest.

Resourcesr/UXDesign · ADPList — free mentorship sessions

TheoryRecruiters check LinkedIn BEFORE portfolios — it's your real landing page. The optimization stack: headline with searchable keywords ("UI/UX Designer | Figma + AI | Open to Work" — recruiters search these terms), banner designed in Figma showcasing your work (default blue = missed real estate), Featured section pinning both case studies + portfolio link, About written as story not resume, and activity — your #60DaysOfDesign posts prove consistency and passion. Engagement strategy: comment thoughtfully on design leaders' posts; their audiences see you.

• Headline keywords decide whether recruiters FIND you at all.
• Featured section = your top shelf: 2 case studies + portfolio link.
• 10 thoughtful comments/week > 1 post/month for visibility.

WatchAnsh Mehra — LinkedIn for designers

PracticeFull LinkedIn overhaul: headline, Figma-designed banner, Featured section with both case studies. Draft your "60 days ago I couldn't open Figma" journey post (schedule for Day 60). Follow 20 Indian design leaders and start engaging daily.

ResourcesLinkedIn · @designaiacademy — daily design tips

TheoryResume reality: an ATS bot reads it before any human does — heavy graphics, columns, and icons confuse parsers and get you silently rejected. The format: ONE page, clean single column, standard fonts. Content order: name + portfolio link on top → skills (Figma, prototyping, user research, AI tools — mirror the job description's words) → projects written as OUTCOMES ("Designed and tested a mess-food app with 12 users; task success improved across 2 iterations") → education. Verbs + numbers beat responsibility lists.

• Every project line: verb + what + evidence ("tested with 5 users…").
• Mirror keywords from each job description — ATS matches terms literally.
• Filename matters: "Priya_Sharma_UIUX_Designer.pdf", never "resume_final_v2.pdf".

WatchUX resume + ATS tips

PracticeDraft in Figma or Google Docs. Run it past Claude: "Review as a design recruiter at Razorpay. Be brutal." Export as "YourName_UIUX_Designer.pdf" — one master + tweakable versions for startup vs agency vs IT services.

ResourcesCanva resume templates (free) · UX resume cheat sheet

TheoryJob hunting is a SYSTEM, not a mood. Channel map by conversion rate: referrals (highest by far — a referred resume gets read), company career pages (less competition than aggregators), Wellfound & Instahyre (product startups, direct founder/recruiter contact), LinkedIn Jobs (volume + Easy Apply), Naukri (IT services + volume), designaijobs.com & uiuxjobsboard (design-only, less noise). Track everything in Notion: company, role, link, contact person, status, follow-up date. What gets tracked gets done.

• Referral > cold apply: a Day 55 DM that lands a referral beats 20 Easy Applies.
• 25 target companies: mix product startups, agencies, IT services (backup tier).
• Job alerts do the searching for you — set them once, check daily.

WatchAnsh Mehra — Getting design jobs in India

PracticeBuild your Notion job tracker. Add 25 target companies across product startups, agencies (Lollypop, NetBramha, Obvious), and IT services. Set alerts everywhere for "UI/UX Designer", "Product Designer", "Junior Designer" + your city/remote.

ResourcesDesignAIJobs — AI-era design roles · Wellfound India · UI/UX Jobs Board India · Naukri

TheoryNetworking isn't schmoozing — it's showing genuine work to people who can vouch for you. The warm DM formula: (1) specific compliment on THEIR work ("your CRED case study's testing section changed how I document iterations") — proves you're not mass-messaging; (2) 1-line intro ("fresher, 60 days into design, 2 case studies live"); (3) small specific ask ("would you have 15 min for portfolio feedback?"). NEVER ask "any openings?" — feedback asks get replies, job asks get archived. After a good conversation, referrals offer themselves.

• Personalize or don't send — generic DMs poison your name.
• ADPList mentors chose to help — book them without hesitation.
• Ask every mentor: "What would make you hire a fresher?" Log the answers.

WatchDesigner networking & DM strategies

PracticeBook 2 free ADPList mentor sessions. DM 5 designers at target companies with personalized messages. Log every "what would make you hire a fresher?" answer — gold intel.

ResourcesADPList — free design mentors · LinkedIn

TheoryMost design interviews center on a 20–30 min portfolio walkthrough — and presenting is a separate skill from designing. The per-case-study structure: context (1 min: what, for whom) → problem (1 min: the human pain) → process & key decisions (5 min: 2–3 forks in the road, what you chose, WHY) → outcome & learnings (2 min: testing results, what you'd do differently). Traps to avoid: narrating every screen ("then I made this… then this…"), rushing past research, and reading from slides. Interviewers interrupt with "why?" on purpose — pausing to think before answering reads as senior.

• Practice the 10-minute version AND a 3-minute version of each case study.
• Record yourself. Watching it back is painful and mandatory.
• "Why?" interruptions are the test — welcome them, don't fear them.

WatchPortfolio presentation walkthroughs · NN/g on UX portfolios

PracticeRecord yourself presenting case study #1 in 10 minutes. Watch it back, re-record until tight. Then present to a friend who interrupts with "why?" questions — exactly what interviewers do.

ResourcesNN/g on UX portfolios

TheoryThe fresher interview question bank: "Walk me through your process" (= design thinking narrated through YOUR project), "Critique this app" (structure it: usability → visual → content → one prioritized improvement), "Design X for Y" whiteboard challenges (the trap: jumping to solutions — ALWAYS ask clarifying questions first: who's the user? what's the context? what defines success?), "How do you handle feedback?" (tell your Day 51 story), "Favorite/worst designed app?" (have both ready with principle-based reasons). Whiteboards judge your PROCESS out loud, not the final sketch.

• Whiteboard rule #1: clarify before designing. Jumping in = instant red flag.
• Critique structure beats critique brilliance — a framework shows repeatability.
• Prepare 3 app opinions: one favorite, one worst, one recently-improved.

WatchWhiteboard challenge walkthroughs · App critique interview practice

Practice2 timed app critiques (15 min each) on random Indian apps using the structure. One whiteboard practice: "Design a medicine-reminder feature for elderly users." Then a full Claude mock: "You're a design manager at Swiggy interviewing a fresher. Ask questions one at a time, then grade my answers."

ResourcesNN/g: UX interview questions

TheoryTwo money skills today. Take-homes: clarify scope by email first (impressive, not annoying), timebox to what's asked (10 polished screens for a 3-hour brief signals poor judgment, not dedication), show process (a quick flow + 2 wireframe options + final UI beats 6 finals), and present decisions in a short write-up. Negotiation: know your band before any call (fresher UI/UX: ₹3.5–7 LPA; product companies higher), avoid naming a number first ("I'd love to understand the band for this role first"), and negotiate total value — learning, mentorship, growth path — not just base. Every lakh you negotiate now compounds for years.

• Take-home write-up: assumptions → process → decisions → what you'd do with more time.
• Research the company on AmbitionBox/Levels.fyi BEFORE the HR call.
• If forced to give a number, give a range anchored at your target, not minimum.

WatchTake-home assignment strategy · Salary negotiation for freshers

Practice3-hour practice take-home: "Design a splitwise-style expense feature for a UPI app" — treat it as a real submission with a write-up. Then script your negotiation: minimum, target, and your response to "what's your expectation?"

ResourcesLevels.fyi · AmbitionBox (Indian salary data)

TheoryDress rehearsal day — simulate the FULL interview pipeline in one sitting, because real interview days are marathons: 10-min portfolio walkthrough → 15-min app critique → 20-min whiteboard challenge → HR round (tell me about yourself, why design, why us, expectations). Practicing them back-to-back builds the stamina and context-switching real interviews demand. Start with your weakest area from Day 57's mock. End by assembling your interview kit so no logistics can rattle you.

• "Tell me about yourself" = 60-second story: switch/college → 60-day sprint → 2 case studies → why design.
• Simulate real conditions: camera on, screen share, time limits.
• Note 3 improvements after — deliberate practice needs a feedback loop.

WatchFull mock design interviews

PracticeRun the full simulation with a friend, an ADPList mentor, or Claude in voice mode. Write down 3 things to improve. Assemble the interview kit.

ResourcesADPList mock interviews

TheoryLaunch day. The job-hunt math: 5–10 tailored applications/week beats 50 spray-and-pray — tailored means a note referencing the company's actual product ("I studied your onboarding and loved X; my case study tackles a similar problem"). Follow up after 5–7 days, once, politely. Mindset armor: rejection is a pipeline statistic, not a verdict on your worth — even great designers hear 20 no's per yes. Your job now is consistent shots on goal while your skills keep compounding.

• Sustainable rhythm: apply weekly, 1 new case study/month, engage daily.
• Next skills when ready: motion design, advanced AI workflows, or a niche (fintech).
• Interviews themselves teach — every one makes the next better.

WatchFirst design job journeys (motivation fuel)

PracticeApply to your first 10 jobs with tailored notes. Publish your Day 52 journey post. Update Figma Community, Behance, and Dribbble profiles. Plan your next 30 days. You're no longer a beginner. Go get hired. 🎉

ResourcesDesignAIJobs · DesignAI Academy — continue your journey