Frontend Beauty
ESC

Type to search the knowledge base.

Intuit Frontend Interview

Composite Intuit-style frontend prep: JS async questions, component builds, and accessibility on money forms. Loops vary by team and level.

advanced5 min read
  • interview-experience
  • intuit

Composite guidance based on publicly shared candidate reports and common hiring patterns for frontend / UI roles on tax, accounting, and money products. Processes vary by team (TurboTax-like flows, QuickBooks-like ledgers, credit, design system), level, and year. Always confirm with your recruiter. Not affiliated with Intuit.

The classic miss in an Intuit frontend interview is a form that lies. Forty fields, a Save that fires a request per blur, amounts stored as IEEE floats, errors only as a red border. Tax and bookkeeping UIs are scored on accuracy, async orchestration, and accessibility. Visual polish is secondary if a screen reader cannot reach the next-year estimate.

Intuit-style frontend interviews usually mix a JavaScript screen (often series vs parallel async), a component or machine-coding build, and questions about long forms. Do not invent a numbered onsite diary. Ask what your loop actually contains.

Key takeaways

  • Long money forms are the product: validation, save drafts, a11y, not a button library.
  • JS rounds like to see series, parallel, and bounded concurrency as real tools.
  • Never use binary floats as currency. Prefer integer minor units.
  • Loops vary hard by team. Confirm with the recruiter.

Forms, accuracy, and async orchestration

Stage Focus Format
Recruiter Product area, level Call
JS / async screen Promises, scheduling, edges Shared editor
UI build Wizard, form, table Timed pair or take-home
A11y / web platform Keyboard, names, errors Conversation
Behavioral Customer outcomes, quality Call

Mid+ candidates also get a design prompt: a multi-step tax interview, a bookkeeping dashboard, or a W-2 import review. Structure beats buzzwords.

Forms as a state machine

Treat a tax-like flow as steps + a draft document, not as twenty unrelated pages.

  • Draft: answers keyed by question id, dirty flag, last-saved timestamp
  • Navigation: which steps are reachable (you cannot skip a gate)
  • Validation: field-level on blur, step-level on Continue
  • Submit: one in-flight save, idempotent, abort on unmount

Machine-coding practice: multi-step wizard, sortable data table, lite spreadsheet grid, accessible modal. Read accessible forms and errors and inclusive error messages before you talk ARIA.

Errors must be text, associated with the control (label / aria-describedby), and not color-only. Money fields need an accessible name that includes the period (“federal withholding, 2025”), not “input 12.”

Accuracy

JavaScript Number is a 64-bit float. That is the wrong type for IRS cents. Say this out loud and pick a representation:

// Store minor units (cents / paise). Format only at the edge.
function addCents(a, b) {
  return a + b;
}

function formatUsd(cents) {
  const sign = cents < 0 ? '-': '';
  const abs = Math.abs(cents);
  const dollars = Math.trunc(abs / 100);
  const rest = String(abs % 100).padStart(2, '0');
  return `${sign}$${dollars}.${rest}`;
}

If the range exceeds Number.MAX_SAFE_INTEGER, you need BigInt or a decimal library. Details: number precision and IEEE 754, Intl formatting. Rounding rules (half-up vs banker’s) are product decisions. Ask. Do not silently toFixed(2) and hope.

Async orchestration (the JS flavor)

A recurring style of frontend question at money/productivity companies: you have N independent loads (or N dependent ones). Implement series, parallel, and limit. This is not trivia. A tax return that fires 80 unbounded requests on step enter will trip rate limits and lock the tab.

async function series(tasks) {
  const out = [];
  for (const task of tasks) out.push(await task());
  return out;
}

function parallel(tasks) {
  return Promise.all(tasks.map((t) => t()));
}

async function mapLimit(items, limit, worker) {
  const out = new Array(items.length);
  let next = 0;
  async function run() {
    while (next < items.length) {
      const i = next++;
      out[i] = await worker(items[i], i);
    }
  }
  const n = Math.min(limit, items.length);
  await Promise.all(Array.from({ length: n }, () => run()));
  return out;
}

Know the spec-level cousins: Promise.all fails fast and preserves order; allSettled never rejects for input rejections. Interview implementations: async series, async parallel, mapLimit concurrency, retry n times. Cancel with AbortController when the user leaves the step.

Coding and React

Expect ordinary JS coding (arrays, strings, trees) plus React component sense: controlled inputs, keys, effects that save drafts without infinite loops. Prep JavaScript interview, React interview questions, rules of hooks.

For DSA, medium patterns are enough for many FE roles: Two Sum, Merge Intervals, Binary Search. Some teams run a general SDE bar. Ask.

Design (mid+)

Surfaces: guided tax interview, document upload + extraction review, books dashboard, bill pay. Cover:

  1. Legal/financial copy cannot be “placeholder lorem”
  2. Save-in-background vs Continue
  3. Session timeout and “we saved your draft”
  4. i18n of dates and currency (internationalization architecture)
  5. a11y as a requirement, not a stretch (accessibility interview talking points)

Footguns

  • onChange save with no debounce and no abort (races, 429s)
  • Using div + click for Continue
  • Storing money as "19.99" and parsing with parseFloat
  • Hiding required fields behind hover
  • Parallelizing tasks that must be serial (SSN lookup then dependent credits)

Preparation plan (6–8 weeks)

  1. Weeks 1–2: JS async until you can teach series/parallel/limit and the event loop.
  2. Weeks 3–4: Rebuild a wizard and a dense form from memory. Keyboard only.
  3. Weeks 5–6: Timed coding + one money-dashboard design outline.
  4. Weeks 7–8: Mocks. Record yourself explaining rounding and draft save.

Out loud: “I would model the return as a draft document with step validation, save with a single in-flight request and abort on leave, and keep money in integer cents. Independent fetches use a concurrency limit. Dependent fetches run in series. Every field has a name and an error that a screen reader can find.”

Further reading