Spotify Mid-Level UI Designer Interview Preparation Guide

Direct answer. A content-heavy news application supporting low-vision and cognitive-impairment users needs a coordinated set of design guidelines addressing typographic scale, spacing, navigation simplification, and language clarity together, since these populations' needs overlap substantially even though the underlying conditions are different, and progressive disclosure that lets a user get the core information without being forced through every layer of detail.

Typographic scale and spacing. Body text set at a genuinely readable base size (not the smallest size that fits editorial density goals) with generous line-height and paragraph spacing, since dense, tightly-spaced text is harder to track line-by-line for both low-vision readers using partial zoom and cognitively-impaired readers who benefit from clearer visual chunking; support the browser/OS-level text-resize/zoom without breaking layout (WCAG 1.4.4/1.4.10), verified by actually testing at 200 percent zoom, not just declaring relative units were used.

Navigation simplification. A consistent, predictable navigation structure across every article page (the same header, the same location for related-content links) reduces the cognitive load of re-orienting on each new page; avoid deeply nested menu structures in favor of a flatter, more predictable hierarchy.

Language clarity. Plain-language headlines and lead paragraphs stating the core fact before elaboration (which also happens to match good journalistic "inverted pyramid" writing practice), avoiding unnecessarily complex sentence structure in navigational and UI copy specifically (article body text itself is a separate editorial/content question, distinct from interface copy).

Progressive disclosure. A long article's key facts summarized at the top (a "what you need to know" block), with full detail available below for readers who want it, rather than requiring every reader to process the full length before getting the core point, serving both a low-vision reader who finds long-form scanning fatiguing and a cognitively-impaired reader who benefits from getting the gist without needing to hold the whole article's structure in working memory.

Personalization controls. Beyond relying solely on browser/OS-level zoom, offer an in-product text-size control (a simple small/medium/large or numeric-step selector, not assuming users know browser zoom exists or want to use it) and a high-contrast theme toggle as a first-class, easily discoverable setting, not buried several menus deep, since research on low-vision and cognitively-fatigued readers consistently shows many users prefer a control native to the product itself over relying on system-level accessibility settings. Persist the choice per account so it survives across sessions and devices, the same discipline applied to any other accessibility preference.

Validating with research and metrics. Usability-test the specific typography, navigation, and personalization changes with low-vision and cognitive-impairment participants directly, not only a general-audience panel, using concrete reading-comprehension and task-completion tasks (find and correctly summarize a specific article's key fact) rather than only subjective preference ratings. Track product-level metrics before and after the changes ship: time-on-article and scroll depth on long articles as a proxy for whether the summary-then-detail structure is actually being used as intended, adoption rate of the personalization controls themselves (a low adoption rate might mean the controls are hard to find, not unwanted), and any change in accessibility-related support contacts as a lagging indicator.

Trade-offs and pitfalls. A common tension is that editorial/design teams sometimes read "simplify navigation and reduce density" as being in conflict with a content-rich news product's actual value proposition; the resolution isn't removing content, it's providing better STRUCTURE and layering (summary-then-detail, consistent predictable chrome) so the same amount of content becomes more navigable rather than shallower.

Direct answer

Developmental feedback, whether it lands in a formal performance review, a string of recurring code-review comments, or a candid conversation with a cross-team peer, only becomes useful once it's turned into a concrete plan with real milestones, not just a private intention to "do better." Structuring that plan around short checkpoints (for example, roughly 30, 60, and 90 days out), pairing each one with a way to actually show progress, and checking back with whoever raised the feedback rather than assuming the plan alone closes the loop is what separates a real development plan from a good intention that fades.

Structured elaboration

Clarify the specific behavior behind the label. A word like "ownership," "testing," "communication," or "business impact" can mean many different things in practice. Ask for a concrete example of what prompted the feedback, since the plan needs to target the actual behavior, not the label attached to it.

Build a milestone plan with visible checkpoints. An early checkpoint (roughly the first month) is about smaller, low-stakes practice: trying the specific behavior somewhere the cost of a misstep is low, and, where useful, pulling in a resource deliberately, whether that's a course, a mentor, or pairing with a colleague who's strong in that exact area, rather than just resolving to try harder. A middle checkpoint (roughly two months in) is about applying it in a real, higher-stakes setting and actively gathering a read on whether it's landing. A later checkpoint (roughly three months in) is about showing the behavior consistently across contexts, not just with one team or one person who already knows to expect it, and bringing concrete evidence back to whoever gave the original feedback.

Use resources deliberately rather than relying on willpower. A mentor, a targeted course, or pairing with someone strong in the gap area is usually far more effective than simply trying harder at the old approach; naming the specific resource used is part of what makes the plan concrete rather than aspirational.

Create your own way to see progress along the way. Feedback that matters doesn't only arrive at the next formal review; it can also show up informally, in a comment from a colleague or a passing remark. Building in a lighter self-check, or asking a trusted colleague to flag it if the old pattern resurfaces, keeps the plan honest between the big checkpoints.

Worked example

A manager's review notes that communication with other teams needs work, and the specific example given is that cross-team updates tend to arrive late and are too dense to act on quickly. In the first month, the update format changes to lead with the ask and the deadline, and early drafts get a quick review from a mentor before sending, as a low-stakes way to practice the new habit. In the second month, that habit gets applied in a real, higher-visibility setting: proactively posting a mid-sprint update to a cross-team channel before anyone has to ask for one, and paying attention to whether people are actually finding it clearer. By the third month, after several cycles of this, the pattern shows up in the threads themselves: cross-team updates that used to draw a "can you clarify" reply on roughly half of them are drawing one on maybe one in ten, and a direct check-in with a cross-team peer confirms updates now feel timelier and clearer. Both the count and the peer's read get brought back to the manager at the next check-in as evidence the specific behavior has changed, not just a claim that it has.

Trade-offs and pitfalls

Writing a plan and not revisiting it until the next annual review lets the good intention quietly lapse with nobody the wiser. Choosing milestones that describe activities (attended a course, read a book) rather than evidence that the underlying behavior actually changed makes the plan easy to complete without the feedback ever really landing. The other common failure is treating a specific example as an attack to be argued away instead of the concrete anchor it actually is; escalating defensively over one instance of feedback wastes the opportunity the specific example was giving you to target the plan precisely.

Situation & goal
As the UX designer on an agile team, my goal is a one-sprint handoff that lets engineers build the feature with minimal clarification.

Minimum contents in annotated wireframes

• Key screens (flow start → success/error) with clear labels
• Target states and transitions (default, hover, focused, disabled, error)
• Primary interaction notes (click/tap behavior, validation timing)
• Data mapping (which fields map to backend vars / API endpoints)
• Acceptance criteria (Given/When/Then for main happy path + critical edge cases)
• Assets & tokens: links to production-ready icons, images, and design tokens (colors, spacing, typography)
• Accessibility notes: focus order, ARIA roles (extra attributes like role="button" that tell screen readers what an element does), contrast targets, keyboard behavior

Prioritization for fast handoff

1. Acceptance criteria + data mapping (highest)
2. Interaction specs for primary flows
3. Error states & validations
4. Accessibility essentials for launchable compliance
5. Visual assets & tokens

Format & cadence

• Annotate directly in Figma with concise comments, link to a single responsive prototype, and add a short checklist in the ticket.
• Pair with a 15–30 minute walkthrough with engineers during sprint planning.

This ensures engineers have the functional, data, and compliance info to implement in one sprint while keeping detail efficient.

Direct answer
The situation I'd describe is a mid-sized project where my manager wanted me to present a set of results to a client as more conclusive than the underlying data actually supported, because the client relationship was under strain and a confident-sounding update would help. My personal value was straightforward accuracy in what I present, even when the more cautious version is less comfortable to deliver; my manager's approach prioritized relationship repair over precision in that specific moment. I did not treat it as a fight to win outright; I looked for a version of the update that was honest and still served the relationship.

Structured elaboration

1. Name the actual tension precisely, not just "we disagreed." In this case it was not that my manager wanted me to lie; it was a difference in where to draw the line between appropriately confident communication and overstating certainty, which is a much more common and more defensible kind of workplace values conflict than an outright integrity violation.
2. Raise the concern directly and early, privately, before the moment it would matter (the client meeting), rather than either silently complying or making it a public confrontation. I asked my manager one on one what specifically in the data supported the stronger framing, which turned the conversation from a disagreement about values into a conversation about evidence.
3. Offer an alternative that serves the underlying goal your manager actually cares about. My manager's real goal was preserving the client relationship, not the specific wording; I proposed a version that led with the two results we were genuinely confident in, was transparent about the one metric still trending in the wrong direction, and paired it with a concrete next step and timeline. This served the relationship-repair goal without requiring me to overstate anything.
4. Be honest about what you would do if the answer had been no. If my manager had insisted on the original framing after that conversation, my actual next step would have been to ask to attach a short written appendix with the caveated numbers, so the honest version existed in the record even if it wasn't the headline; if that had also been refused, I would have escalated to my manager's manager rather than either comply silently or refuse outright, because the stakes (client trust, and my own credibility if the caveated number surfaced later) were high enough to warrant it.
5. Reflect honestly on what you learned, including about your own judgment, not only about the other person. I learned that raising the concern as a specific evidentiary question ("what supports this framing") got further, faster, than raising it as a values statement ("I'm not comfortable with this") would have, because it gave my manager something concrete to respond to.

Worked example
The client update, as originally proposed, said: "engagement is up and the rollout is on track." What the underlying data actually showed: two of three key metrics had improved meaningfully, but the third (a retention metric the client cared about specifically) had been flat to slightly down for three weeks running, with a plausible but unconfirmed hypothesis for why. The version I proposed and we ultimately sent said: "engagement and adoption are both up meaningfully this period; retention is currently flat, and we have identified a likely cause we're testing a fix for over the next two weeks, with a follow-up update once we have results." The client's actual reaction was more positive than my manager expected, specifically because the concrete next step read as more credible than an unqualified "on track" would have.

Trade-offs & pitfalls
The common failure in answering this question is picking an example that is really just "I disagreed with a decision," with no genuine values dimension, or the opposite extreme, an example so severe (fraud, safety, legal risk) that it reads as a one-time crisis story rather than the kind of ordinary, recurring tension this question is actually probing for. Another pitfall is describing the resolution as pure capitulation ("I raised it once, they said no, I dropped it") or pure martyrdom ("I refused and it cost me"), neither of which shows the judgment interviewers are actually testing for: the ability to find a version of the truth that serves both your own integrity and the legitimate underlying goal the other person had.

Direct answer

I wouldn't average the two requests into a watered-down middle that leaves both stakeholders unhappy. I'd first find out what each person actually needs the surface to DO (their underlying job to be done, not just their stated preference), then look for a way to serve both through layering rather than a single static layout, and only force an explicit trade-off if layering genuinely isn't possible.

Structured elaboration

1. Separate 1:1 conversations before any group negotiation. Ask each stakeholder what decision or task the surface needs to support for them, not just what they want it to look like. "Simplify it" and "show everything" are usually proxies for different underlying needs.

2. Map both asks to real use cases. Write down what each stakeholder is trying to accomplish. Frequently the surface reveals overlap (both actually care about the same three numbers) and a genuine point of divergence (one needs quick scanning, the other needs completeness for a specific edge case).

3. Look for a layered solution first. Progressive disclosure, a default simple view with an expandable "advanced" or "details" section, often satisfies both asks without anyone losing anything: the person who wants simplicity gets it by default, and the person who wants completeness gets it one click away.

4. If layering truly can't resolve it, make the trade-off explicit. Some surfaces really do have one primary audience. In that case, say so directly, name who the primary audience for that specific surface is, and explain why, rather than hiding the decision inside a mushy compromise that quietly favors one side.

5. Socialize the recommendation together, framed around the shared goal. Bring both stakeholders into the same conversation (not two separate ones for the final call) and frame it around the review going well, not around who "won."

Worked example

On a B2B account settings screen, the VP of Sales wants it simplified to three fields "so reps can demo it live without confusion." The Head of Customer Success wants every configurable option visible, because support logs show 340 tickets over the last quarter, roughly 3.8 a day, tied to users unable to find settings buried in submenus. Meanwhile sales reports that clutter caused visible confusion in 6 of their last 10 live demos.

Both needs are real and don't actually conflict once separated: sales needs a clean surface to demo three headline controls, and support needs the other 14 settings to be findable, not necessarily always visible. The resolution is a default view showing the three primary controls sales demos, with a single "Advanced settings" expandable section revealing the remaining 14 fields. New accounts land on the collapsed default; accounts that have already navigated into advanced settings once keep it expanded. Over the next 30 days, click-through on the "Advanced settings" toggle is tracked as a proxy for whether the layered model actually reduces the discoverability problem support was flagging, against the 3.8-ticket-per-day baseline.

Trade-offs and pitfalls

• The most common mistake is negotiating a literal 50/50 split, showing roughly 8 of the fields, which usually satisfies neither the "clean demo" need nor the "find everything" need.
• It's easy to broker stakeholder opinions directly instead of tracing the underlying job each person needs done; that produces a compromise that looks fair but solves nothing.
• When a genuine either/or split exists and can't be layered away, naming the trade-off honestly (and who the primary audience is) is more durable than a hybrid that quietly favors one side while pretending to please both.
• A layered solution still needs a follow-up check: if the "advanced" section barely gets opened, that's a sign the underlying need wasn't actually served, just hidden from view.

Overview / Goals
Design a scalable component system (atomic design) that supports responsive variants while keeping maintenance feasible, predictable, and developer-friendly.

Structure: atoms → molecules → organisms

• Atoms: single-purpose primitives (color tokens, type, spacing, icon, button base). They expose only design tokens (no layout).
• Molecules: composed atoms with limited layout (form field = label + input + helper). Accept tokenized inputs and minimal responsive props.
• Organisms: page-level composites (nav, card grid) that orchestrate molecules and decide layout breakpoints.

When to create breakpoint-specific variants

• Create responsive variants only when visual or UX behavior differs (e.g., stacking vs inline, different spacing / visibility). Prefer fluid, token-driven styles first; add discrete variants for structural changes (reflow, different markup).
• Rule of thumb: make breakpoint variant when behavior changes, not for trivial spacing tweaks.

Tokens flow

• Central token system (color, type-scale, spacing, radius, breakpoint definitions).
• Components consume tokens via mapping layer: theme → tokens → component props. Designers define tokens in Figma; engineers import same token JSON. Components should never hardcode values.

Preventing combinatorial explosion

• Prefer tokenization and inheritance: control size/variant/spread via tokens not separate components.
• Limit axes: allow at most 2 variant axes per component (e.g., size × intent). Use responsive props that accept token scales (e.g., padding: [sm, md, lg], mapping to real values like 8px, 16px, 24px) rather than separate variants per breakpoint.
• Use composition over duplication: build complex behaviors by composing smaller components.
• Governance: a documented variant matrix, a review process for new variants, and usage telemetry, so unused variants get removed periodically rather than accumulating forever.

Example

• Button: atoms (base styles, e.g. padding-sm: 8px, padding-md: 16px, padding-lg: 24px) → molecule (Button with size x intent variants, where "intent" is the design-system term for the button's semantic purpose, such as primary, secondary, or danger, which usually drives its color rather than its size). Responsive behavior: accept a responsive size array (e.g. size: [sm, md, lg] mapped per breakpoint); create an explicit "block-on-mobile" variant only if the layout itself should change, not just the size.

Direct answer

Every confounder on this list shares one weakness: something other than the design change is moving at the same time as the design change, and a naive before/after or two-group comparison can't tell the two apart. The single strongest defense against most of them is a randomized concurrent control group, since randomization means whatever else is happening (a campaign, a season, a bug) is, on average, hitting the treatment and control arms equally, so it cancels out of the comparison. Where true randomization isn't available, each confounder needs its own specific mitigation instead.

Structured elaboration

Trade-offs and pitfalls

Notice the pattern: nearly every mitigation either IS a randomized concurrent control or is a workaround for not having one. That's the practical lesson, not a coincidence: a team without the infrastructure to run true randomized experiments will spend far more effort defending each individual confounder one at a time, and will still be more exposed to the ones nobody thought to name in advance. The common mistake is treating this list as exhaustive and stopping there; the real discipline is asking, for any given launch, "what else is different between the before and after periods, or between my two groups, besides the thing I'm testing?" every time, not just checking off this specific list.

Direct answer

Pick a base size that matches your platform's default reading size, apply a consistent multiplier (the scale ratio) to generate a small, predictable set of larger and smaller sizes, then pair each size with a line-height and line-length that keep text comfortable to read, and adjust the whole scale, not just individual sizes, at responsive breakpoints.

Structured elaboration

Base font size: start from 16px, the common browser default for 1rem, since it is predictable for both users' accessibility settings and for developers translating a design into code. For a touch-first, reading-heavy product an 18px base is a reasonable alternative, but 16px is the safer default absent a specific reason to change it.

Scale ratio: a modular scale multiplies the base size by a fixed ratio repeatedly to generate each larger step (and divides for smaller ones), so that every size relates to every other size by the same proportion instead of being picked ad hoc. Common ratios include 1.125, 1.2, and 1.25 (design tools often label these by their nearest musical interval: 1.125 as a major second, 1.2 as a minor third, and 1.25 as a major third). A ratio around 1.2 is a good default for interface type: moderate steps that create clear hierarchy without jarring jumps between adjacent levels.

Line length (also called measure): aim for roughly 45 to 75 characters per line for long-form body text, tightening to around 30 to 45 characters for compact contexts like cards or sidebars. Lines much longer than this make it hard for the eye to find the start of the next line; much shorter and reading feels choppy.

Line-height (leading): use looser line-height for body text, around 1.4 to 1.6, and tighter line-height for headings, around 1.1 to 1.3, since large text needs proportionally less vertical space between lines to stay comfortable. Express line-height as a unitless multiplier (for example 1.5, not 24px) so it scales correctly if the font size changes.

Responsive breakpoints: keep sizes expressed in rem units relative to the root font size, then adjust the root size itself at breakpoints (for example 100% on mobile, 112.5% on desktop) so every size in the scale grows or shrinks together, rather than manually overriding each heading size individually at every breakpoint.

Worked example

Using a base of 16px and a ratio of 1.2, the scale multiplies at each step: 16, 19.2, 23.04, 27.648, 33.178, 39.813, which rounds to 16, 19, 23, 28, 33, 40px.

:root { font-size: 100%; } /* 1rem = 16px */
body  { font-size: 1rem; line-height: 1.5; }
.h2   { font-size: 1.75rem; line-height: 1.2; }   /* 28px */
.h1   { font-size: 2.0625rem; line-height: 1.15; } /* 33px */

@media (min-width: 1024px) {
  :root { font-size: 112.5%; } /* root becomes 18px, whole scale grows with it */
}

Trade-offs and pitfalls

Choosing too aggressive a ratio (1.5 or higher) on a small base produces only three or four usable sizes before text becomes impractically large for a dense interface, since each step jumps a large amount. Choosing too flat a ratio (below 1.125) does not create enough size contrast between heading levels, forcing hierarchy to lean entirely on weight and color instead. A further pitfall is applying the full numeric scale to every piece of text on the screen. Most interfaces only need three or four of the generated steps in practice (body, a subheading, a heading, maybe a caption), and forcing every in-between step into use creates visual clutter rather than clarity.

Direct answer

Use a single monorepo with a canonical token package as the single source of truth, a build-time transform that compiles those tokens into each platform's native format, and per-platform packages that hold only rendering code and a thin adapter mapping tokens to platform primitives. Nothing about visual intent (color, spacing, type scale) should be re-authored separately for web, iOS, and Android; only the code that consumes it differs.

Structured elaboration

flowchart TD
  A[packages/tokens] --> B[packages/primitives]
  B --> C[apps/web]
  B --> D[apps/ios]
  B --> E[apps/android]
  A --> F[scripts/transform]
  F --> C
  F --> D
  F --> E

Handling platform-specific divergence while minimizing duplication: the default is that a component's behavior is identical everywhere, defined once in packages/primitives/Button/spec.md (anatomy, states, accessibility role and keyboard/focus behavior). When a platform genuinely needs to diverge (a native iOS sheet-style modal vs. a web overlay), that divergence lives entirely inside that platform's own implementation folder and its adapter, with the reason documented directly in the spec so it's traceable, not discovered by reading three separate codebases and guessing why they differ. Reach for a prop or variant on the shared spec first before writing platform-specific logic; only fall back to separate implementations when the platform's own interaction idiom (not just its rendering engine) genuinely requires it.

Worked example

A single spacing token, space.md = 8, and a single color token, color.brand.primary = #2D6CDF, flow through scripts/transform into three outputs:

/* apps/web: generated CSS custom properties */
:root { --space-md: 8px; --color-brand-primary: #2D6CDF; }

// apps/ios: generated Swift token enum
enum Spacing { static let md: CGFloat = 8 }
enum ColorToken { static let brandPrimary = UIColor(hex: "#2D6CDF") }

<!-- apps/android: generated resources -->
<dimen name="space_md">8dp</dimen>
<color name="color_brand_primary">#2D6CDF</color>

All three are generated from the same canonical value by the same transform step (a Style Dictionary-style build), so a spacing or color update happens once in packages/tokens/ and regenerates all three outputs together, instead of three engineers manually keeping numbers in sync.

Trade-offs and pitfalls

A single monorepo needs workspace-aware tooling (a build system that understands package boundaries) to avoid every platform rebuilding on every unrelated change; three separate polyrepos avoid that tooling cost but tokens drift the moment one repo updates its copy and forgets to notify the others. The most common pitfall is letting platform adapters absorb actual business logic instead of pure token-to-primitive mapping, which makes the divergence impossible to audit later. The second is skipping the shared spec.md and letting each platform team invent its own undocumented behavior differences, which is exactly the drift a cross-platform system is supposed to prevent.

Direct answer
Ramping someone from day one to their first shipped work is a deliberate sequence, not a single onboarding checklist: assess what they actually already know, give them small real tasks with tight review loops before a full feature, gradually widen the scope of ownership, and define upfront what "shipped" and "done" mean so the finish line is unambiguous. The plan should look different depending on who's arriving, not just be a fixed template applied to everyone.

Structured elaboration

The default arc

• First few days: orient and assess. Don't assume a blank slate; find out what they already know so you're not re-teaching things or, worse, skipping things they actually need.
• Early tasks: small, real, low-blast-radius work with fast, close review. The goal here is confidence and calibration to the team's standards, not speed.
• Middle stretch: progressively larger scope with more independence, review shifting from "check everything" to "check the risky parts."
• First real shipped piece: something end-to-end they own, with you available but not doing it alongside them, and a clear definition of "done" agreed before they start, so success isn't a moving target.

Adapting the plan to who's actually arriving

This is where a generic checklist breaks down, and it's the part that separates a senior answer:

• A contractor under least-privilege or compliance constraints: access is scoped down from day one, so the plan has to work around what they legitimately can't see or touch, and documentation often needs to be more explicit since they can't casually ask around as easily as a full-time hire embedded in the org.
• A career-changer from an adjacent discipline (a backend engineer moving into data engineering, a research scientist moving into production ML): they're not a blank slate, they have real transferable skills. The plan should explicitly identify what carries over and target ramp-up specifically at the actual new-domain gaps, not restart from zero the way you would for someone with no relevant background.
• A cohort of remote interns rather than one hire: 1:1 pairing time doesn't scale to a group. The plan shifts toward a shared structured curriculum, peer learning between the interns, and scheduled office hours, with 1:1 time reserved for the things that genuinely need it.
• A remote hire versus a senior IC joining: a remote hire needs more of everything written down explicitly, since the informal hallway learning that fills gaps for an in-person hire doesn't happen by accident. A senior IC's gap is usually organizational context and relationships, not raw skill, so their plan should be lighter on procedural scaffolding and heavier on introductions, context on how decisions get made, and where the landmines are.

Worked example

Situation

I mentored someone joining as an individual contributor with solid general skills but no exposure to our specific stack or codebase, with a goal of them shipping one real, complete piece of work within their first several weeks.

Action

Week one was mostly orientation and a short assessment task to see where they actually stood, not a generic reading list. From there, I gave them a small real bug fix with a tight review loop so they got fast, specific feedback on our conventions early, before those habits calcified the wrong way. Over the following weeks the scope widened: a small self-contained feature with me reviewing closely, then a larger piece with me available but stepping back from line-by-line review, focusing instead on the riskiest parts of the design.

Result

They shipped a real, complete piece of work end-to-end within the target window, with a review pass that looked much closer to how we review any other team member's work by that point, which was the actual signal of readiness, not just that the calendar had passed.

Trade-offs & pitfalls

• Treating every new hire's plan as the same template. A junior mentor runs the same onboarding for a contractor, a career-changer, an intern cohort, and a senior IC. A senior mentor adapts the shape of the plan to who's actually arriving, because the actual gap being closed is different in each case.
• Under-scoping early tasks out of excessive caution, or over-scoping out of impatience. Both undermine the confidence-building purpose of the early stretch: too small and it's condescending or boring; too large too soon and the first review becomes overwhelming and demoralizing.
• Not defining "done" up front. Ambiguity about what counts as finished either causes needless rework or lets something ship that isn't actually ready, and both erode trust in the mentoring relationship.
• Ignoring the constraints a nontraditional hire is actually operating under. Applying a full-access, in-person, junior-IC plan to a least-privilege contractor or a remote hire sets them up to fail on logistics that have nothing to do with their actual skill.