Interview experience
Intuit interview experiences covering Recruiter screen, Online Assessment, Technical interview(s), Craft Demo (SDE-2+ / senior), +2 more. Round-wise notes, common questions, and what candidates report clears each stage.
Intuit Interview Questions and Answers (2026)
Intuit is a global financial software company best known for QuickBooks, TurboTax, and related products that help small businesses and consumers manage finances. In India, Intuit hires product engineers to build cloud-based financial tools used by millions of customers worldwide.
HQ: Mountain View, California, USA
Employees: 18,000+
Revenue: $18.8+ Billion USD
Website: intuit.com ↗
Explore: Interview experience · HR interview questions · Overview · Placement papers · Preparation guide
Overview
Intuit’s engineering interviews pair standard DSA rounds with a live Craft Demo on real code, evaluated through its Design for Delight framework.
HR interview questions
Intuit HR interview questions with sample answer frameworks - motivation, relocation, STAR stories, and culture-fit prompts.
Intuit interview process at a glance
| Round | Duration | What it tests |
|---|---|---|
| Recruiter screen | 30-40 min | Background, motivation, location/comp, logistics |
| Online Assessment | 60-90 min | 2-4 DSA problems on the Glider platform |
| Technical interview(s) | 30-60 min each | Coding, OOPs/DBMS/OS fundamentals, project deep-dive |
| Craft Demo (SDE-2+ / senior) | ~90 min | Live coding on a shared codebase - tests, error handling, communication |
| System design (SDE-2+) | 45-60 min | Scalable design and trade-offs (storage, notifications, etc.) |
| Hiring manager / HR | 20-30 min | Values fit, Design for Delight thinking, closing logistics |
Intuit online assessment: quick answers
These answers are compiled from public candidate reports, not from an official Intuit notice, and the test differs by level, campus and year. The instruction screen of your own test is the final word.
| Question | Answer |
|---|---|
| Which platform is it on? | Glider (Glider.ai) in most candidate reports, including a 2025 Bengaluru SDE-1 write-up. A 2021 off-campus SDE-1 candidate took it on HackerEarth. |
| How many questions and how long? | Reports vary. One format is 4 coding problems (one easy, two medium, one hard) in about 90 minutes. Others pair 5-10 MCQs with a coding section capped at 30 minutes. A November 2025 SDE-1 test had two DSA problems and one SQL problem; a September 2025 intern test had five DSA problems. |
| What do the MCQs cover? | Java, OOP, design patterns and SQL, with each MCQ timed separately (30-90 seconds in one report). 2025 mass-screening reports also mention static vs instance methods, factory patterns and JSON or API basics. |
| Can I go back to a question? | Usually no. Candidates report that each question has a fixed time limit and you cannot return to an earlier question, so do not skip expecting to come back. |
| Does it have negative marking? | No public candidate report mentions negative marking, and Intuit does not publish a marking scheme. |
| Is there a sectional cutoff? | Not published. Reports say fully passing the easier coding problems counts for more than a partial attempt at the hardest one. |
| How much is the cutoff? | No test cutoff is published; shortlists are relative to the batch. Intuit does not publish a CGPA rule for India hiring, so follow your campus notice or the job listing. |
| Is the Craft Demo part of the fresher process? | Usually not. The Craft Demo is reported mainly on SDE-2 and senior loops; fresher and intern loops are the online test, technical rounds and an HR or recruiter round. |
Intuit interview questions by level
These themes come from candidate reports on Glassdoor, LeetCode Discuss, Naukri Code360 and the Roundz SDE-1 write-up for Intuit Bengaluru. They show the level and style, not a fixed list.
| Level | Reported questions and topics |
|---|---|
| Intern | Arrays and linked lists plus CS fundamentals across two technical rounds (September 2025); C++, DBMS, BSTs and the Sieve of Eratosthenes (2024 report). |
| SDE-1 (new grad) | Decode string, searching a sorted matrix, an O(1) insert-delete-getRandom structure, ACID properties, OOP and OS (2025 Roundz write-up); graph-heavy coding with DP and arrays (January 2024); a string-counting problem with Rabin-Karp and KMP follow-ups (2021). A March 2026 candidate was also asked how they use AI coding assistants and about code quality. |
| SDE-2 / senior | The Craft Demo: implement one or two user stories live in a GitHub repo shared 24-48 hours earlier, with tests and error handling, then a system design round (file storage, notifications, roles and permissions). |
| Senior (OA) | An experienced-hire India OA reported on LeetCode Discuss asked for a palindrome linked-list check. |
Asked across every level: a deep project walk-through, edge cases and optimisation on every coding answer, and a story that maps to Design for Delight (customer empathy or rapid experimentation).
Recruiter screen
A 30-40 minute call to confirm background, work authorization, location, and current comp/notice period. It’s a logistics filter more than a technical bar - be direct about timeline and expectations.
Common questions
- Walk me through your resume/current role
- Why are you interested in Intuit right now?
- What are your compensation and location preferences?
- What’s your notice period / earliest start date?
Full behavioral frameworks are on the Intuit HR interview questions page.
Online Assessment
A 60-90 minute timed test, usually on the Glider platform: typically 2-4 coding problems spanning easy to hard difficulty, often paired with MCQs on OOP, SQL, and JSON/API basics. Mass-screening reports (2025) describe a balanced mix - static vs instance methods, encapsulation, factory patterns, SQL for duplicate salary rows, plus coding such as largest n-digit number with digit sum s and minimum operations to transform array A into B (+1, -1, copy). Candidates report that clean, fully-passing solutions on the easier problems weigh more than a partial attempt at the hardest one.
Common questions
- Matrix traversal: find a path/target in a grid of 0s and 1s (robot paths down/right only - count ways)
- Data structure design: O(1) insert, delete, and getRandom
- Tree/graph problems: e.g. delete a node and return the remaining forest as an array
- String/array problems in the “decode string” or “unique email addresses” family
- MCQs: OOP fundamentals, SQL result sets, serialization/JSON safety
See how real candidates handled this stage on the Intuit interview experience page.
Technical interviews
One or two rounds of 30-60 minutes each, usually with one or two interviewers. Expect a mix of live coding, core CS fundamentals, and a genuine deep-dive into a project from your resume - not just a listed-skills recap.
Common questions
- OOPs: polymorphism (compile-time vs runtime), inheritance, and where you’ve used them
- DBMS: ACID properties, indexing, normalization
- Operating systems: deadlocks, process vs thread
- Resume project deep-dive: architecture choices, the hardest bug, what you’d rebuild
Round-by-round breakdowns are on the Intuit interview experience page.
Craft Demo: Intuit’s distinctive round
This is the round most candidate reports single out as unusual to Intuit. Roughly 24-48 hours before the interview, you’re emailed access to a small GitHub repository with a partially-built application. In the ~90-minute session itself, 2-4 interviewers watch you implement one or two new user stories live inside that existing codebase - not a fresh whiteboard problem. The bar isn’t just “does it run”: interviewers are explicitly watching for test coverage, error handling, and whether you narrate your reasoning as you extend someone else’s code, since that’s closer to day-one engineering work than a LeetCode round.
Common questions
- Implement a new feature/user story inside the provided repo, matching existing code style
- Add unit tests and handle edge cases for the feature you just wrote
- Explain why you structured the change the way you did, and what you’d refactor with more time
- Follow-up questions tied to Design for Delight: how would you validate this feature actually solves the user’s problem?
Design for Delight and Intuit’s operating values
Intuit’s own innovation methodology - Design for Delight (D4D) - shows up as an evaluation lens in the Craft Demo and behavioral rounds, not just as company trivia. Its three principles are Deep Customer Empathy (understand the real problem before proposing a fix), Go Broad to Go Narrow (consider more than one option before committing), and Rapid Experimentation (test cheaply before building the whole thing). Layered on top are Intuit’s five operating values: Integrity without Compromise, Courage, Customer Obsession, Stronger Together, and We Care and Give Back. Interviewers use both as a shared vocabulary, so naming which principle or value a story maps to - briefly, not as a buzzword drop - tends to land better than a generic answer.
Common questions
- Tell me about a time you validated an idea with real users before building it (Deep Customer Empathy / Rapid Experimentation)
- Describe a time you considered multiple approaches before picking one (Go Broad to Go Narrow)
- Tell me about a time you did the right thing even when it was inconvenient (Integrity without Compromise)
- Why Intuit, specifically, over other fintech/SaaS companies?
System design (SDE-2 and above)
A 45-60 minute round for more senior candidates, focused on a concrete, scoped system rather than an open-ended “design Google” prompt. Interviewers probe estimation, trade-offs, and failure modes as much as the final diagram.
Common questions
- Design a photo/file storage service - upload, download, sharing at scale
- Design a notification or alerting service
- Design a roles-and-permissions system for a multi-tenant product
- How would you estimate load and storage for the system you just designed?
Hiring manager / HR round
The closing conversation checks fit against Intuit’s values and logistics: location, compensation band, and a couple of behavioral stories. Prepare those answers on the dedicated page rather than cramming them into this hub.
Common questions
- Tell me about a time you advocated for the customer even when it meant pushing back internally
- Describe a decision you made by relying on data rather than intuition - what was the outcome?
- Are you willing to relocate / what’s your notice period?
- Do you have any questions for us?
Sample answer frameworks for each of these are on the Intuit HR interview questions page.
Intuit fresher loop vs experienced loop
The two loops share a name but not a shape. Freshers and interns take the online test (usually on Glider), then one or two technical rounds on DSA, OOP, DBMS and OS, then an HR or recruiter conversation. There is no Craft Demo and no dedicated system design round in most fresher reports.
Experienced candidates (SDE-2 and above) usually skip the mass online test or take a shorter one, and the loop centres on the Craft Demo, where you extend a real codebase live, plus system design and a hiring-manager round on Intuit’s values. This page covers both; check your invite to see which loop you are in before you prepare.
Common technical interview questions and answers
Q: Design a data structure supporting insert, delete, and getRandom in O(1).
Combine a dynamic array with a hash map from value to that value’s index in the array. Insert appends to the array and records the index in the map. getRandom picks a uniformly random index into the array, which is O(1) precisely because the array is dense with no holes. The trick is delete: instead of removing from the middle and shifting, look up the index of the target, swap in the last element of the array, update that moved element’s index in the map, then pop the last slot and erase the target from the map. All three operations are O(1) average and the structure uses O(n) space. The follow-up variant that allows duplicates replaces the map value with a set of indices per value.
Q: Given a binary tree and a list of values to delete, return the remaining forest.
Do a post-order traversal so children are processed before their parent, carrying the deletion values in a hash set for O(1) membership checks. At each node, recurse left and right first, then check whether the node itself is to be deleted: if it is, add its surviving children to the result list as new roots and return null to its parent so the parent unlinks it; if it is not, return the node unchanged. After the traversal, add the original root to the result only if it was not itself deleted. This is O(n) time and O(h) space for the recursion stack. Post-order matters because you must know whether a child survived before you can decide whether it becomes a new root.
Q: Implement decode string - for example, 3[a2[c]] returns accaccacc.
Use two stacks, one for repeat counts and one for partial strings, walking the input once. On a digit, accumulate the full multi-digit number. On an opening bracket, push the current count and the current partial string, then reset both. On a closing bracket, pop the count and the previous string, and set the current string to the previous string plus the current string repeated count times. On a letter, append it to the current string. This runs in O(total output length) time and O(depth) stack space. The two details interviewers probe are multi-digit numbers such as 12[ab], and nested brackets, both of which the two-stack approach handles naturally.
Q: What is the difference between compile-time and runtime polymorphism?
Compile-time polymorphism, also called static binding, is method overloading and operator overloading: several methods share a name but differ in their parameter lists, and the compiler picks one from the declared argument types. Runtime polymorphism, or dynamic binding, is method overriding: a subclass redefines a parent method with the same signature, and the decision of which implementation runs is deferred to run time based on the object’s actual type, dispatched through a vtable in C++ or by the JVM in Java. The practical consequence Intuit interviewers look for is extensibility - runtime polymorphism lets you add a new subclass without touching the calling code, whereas overloading is only a convenience for the caller. Note that in Java, static, private, and final methods are bound at compile time and therefore cannot be overridden.
Q: Explain normalization, and when would you deliberately denormalize?
Normalization decomposes tables so each fact is stored exactly once: 1NF requires atomic columns, 2NF removes partial dependencies on part of a composite key, and 3NF removes transitive dependencies between non-key columns. The payoff is that an update touches one row, so update, insert, and delete anomalies disappear. You denormalize when read performance under a known access pattern matters more than write simplicity - for example, storing a precomputed comment_count on a post rather than running a COUNT join on every page load, or duplicating a product name into an order-line row so historical orders do not change when the catalogue does. The cost is that you now own the consistency: every write path must update both copies, usually via a transaction, a trigger, or an asynchronous job that you must then monitor for drift.
Q: What is the difference between a mutex and a semaphore?
A mutex is a locking mechanism with ownership: exactly one thread holds it at a time, and only the thread that locked it may unlock it, which makes it the right tool for guarding a critical section. A semaphore is a signalling mechanism holding a counter: threads call wait to decrement (blocking at zero) and signal to increment, and any thread may signal, including one that never waited. A binary semaphore looks superficially like a mutex but lacks ownership, so it cannot support priority inheritance and is easier to misuse. Use a counting semaphore when you are limiting access to N interchangeable resources, such as a pool of ten database connections, and a mutex when you are protecting one shared piece of state.
Q: How would you design a notification service?
Start with an ingestion API that accepts a notification request and immediately writes it to a durable queue such as Kafka, so the caller is not blocked by delivery latency. Workers consume from that queue, look up the user’s channel preferences and quiet hours, apply rate limiting and deduplication (a hash of user, template, and time bucket held in Redis), and then fan out to channel-specific senders for push, email, and SMS. Each sender needs retries with exponential backoff and a dead-letter queue for permanent failures, since third-party providers fail transiently. Make delivery idempotent using a notification ID, because at-least-once queue semantics guarantee some messages get replayed - without that, users receive duplicates. For estimation, state your assumptions out loud: notifications per day divided by 86400 gives average writes per second, and you should size for a peak several times that.
Q: How would you find the shortest path through a grid of 0s and 1s?
Use BFS from the start cell, because BFS on an unweighted graph reaches every cell by the fewest moves the first time it arrives there - so the moment you dequeue the target, the distance recorded is optimal. Push the start into a queue with distance 0, mark it visited, and on each pop expand the four neighbours that are in bounds, are passable, and are unvisited. Time and space are both O(rows x cols) since each cell is enqueued at most once. DFS is the wrong choice here: it will find a path but not necessarily the shortest one. If the cells carry different traversal costs, upgrade to Dijkstra with a priority queue, and if a good heuristic exists such as Manhattan distance, A-star prunes the search further.
Q: Count robot paths in a binary grid (down/right only)?
Classic OA variant: from top-left to bottom-right through cells marked 1, moving only right or down. Use DFS with memoization or DP on (row,col) storing paths from that cell to the destination; add paths from (r+1,c) and (r,c+1) when those cells are valid. Base case: destination cell returns 1; invalid or 0-cell returns 0. Time O(rows × cols), space O(rows × cols) for memo. Clarify whether the start/end must be 1 and whether the grid can be empty.
Q: Largest n-digit number whose digits sum to s?
Greedy from the leftmost digit: for each position, pick the largest digit d such that the remaining positions can still reach sum s (remaining positions × 9 ≥ s - d). Avoid leading zero unless n=1 and s=0. If no valid digit exists at any step, return -1. Watch constraints up to n=10⁵ - the greedy check is O(1) per digit, so overall O(n). Reported in Glider mass-screening OAs.
Q: What does Intuit’s Craft Demo REST task usually look like?
Common pattern: Spring Boot (or similar) repo with H2/Postgres, implement a user story such as GET /players?isAdmin=true returning first+last names for admins and first names only for regular users; add JUnit tests; demonstrate in Postman; extend with pagination/sorting and role-based access in follow-ups. Panels grade requirement clarification, HTTP status codes, exception handling, and tests - Bengaluru SDE-2 reports cite rejections when error codes were sloppy even if happy path worked.
Q: How should you answer “how would you validate this feature with customers?”
Use Design for Delight language: state a customer problem statement, propose a cheap experiment (prototype, concierge test, A/B on a small cohort), define success metrics before building, and say what you’d pivot if results fail. Tie to TurboTax/QuickBooks-style users if relevant - small business owners, filers, not abstract “users.”
Frequently asked questions about Intuit interviews
Does the Intuit online assessment have negative marking?
No public candidate report mentions negative marking, and Intuit does not publish a marking scheme. The test is usually on Glider with timed MCQs on Java, OOP, design patterns and SQL plus coding problems, and candidates report you cannot go back to an earlier question once you move on.
Which platform is the Intuit online assessment on?
Glider (Glider.ai) in most candidate reports, including 2025 Bengaluru SDE-1 reports; one 2021 off-campus candidate took it on HackerEarth. Formats vary from 4 coding problems in about 90 minutes to 5-10 timed MCQs plus a 30-minute coding section.
What is the Intuit interview process for engineers?
Intuit’s engineering loop typically runs: 1. Recruiter screen (30-40 min) - background, motivation, logistics. 2. Online Assessment (60-90 min on the Glider platform) - 2-4 DSA problems. 3. One or two Technical interviews (30-60 min each) - coding, OOPs/CS fundamentals, and a project deep-dive. 4. Craft Demo (around 90 min, common on SDE-2+ and senior loops) - live coding on a codebase shared 24-48 hours in advance. 5. System design (SDE-2+) and a closing Hiring Manager/HR conversation (20-30 min). Community-reported timelines put the full process at roughly 3-6 weeks.
What is Intuit’s Craft Demo round?
The Craft Demo is Intuit’s most distinctive round, reported mainly on SDE-2 and senior loops. Candidates get access to a small GitHub repository 24-48 hours ahead of time and are asked to implement 1-2 new user stories live in front of 2-4 interviewers, roughly 90 minutes total. It’s scored on working code, but also on test coverage, error handling, and how clearly you explain trade-offs while you build - closer to a real code review than a whiteboard problem.
What is Design for Delight (D4D) and why does it come up in interviews?
Design for Delight is Intuit’s internal innovation framework, built on three principles: Deep Customer Empathy, Go Broad to Go Narrow, and Rapid Experimentation. Interviewers - especially in the Craft Demo and behavioral rounds - often use it as a lens: they want to hear how you understood a user’s real problem, considered more than one option, and tested an idea cheaply before committing, not just that you shipped something.
What questions are asked in Intuit interviews?
Coding rounds lean on arrays/strings, matrix traversal, tree/graph problems (e.g. delete a node and return the remaining forest), and data-structure design questions (O(1) insert/delete/getRandom). CS fundamentals cover OOPs, DBMS (ACID, indexing), and operating systems basics. System design rounds (mostly SDE-2+) ask for things like a photo-storage or notification service. Behavioral and Craft Demo rounds probe Intuit’s five operating values and its Design for Delight framework.
How many rounds are there in the Intuit interview?
Most community-reported loops describe 4-6 stages: recruiter screen, Online Assessment, one or two technical interviews, an optional Craft Demo (common at SDE-2+), and a closing hiring-manager/HR round. Exact composition varies by level and team, so treat this as a range, not a fixed script.
Does Intuit hire at TCS/Infosys-style campus scale?
No. Intuit’s Bengaluru office does hire new graduates, but candidate reports describe a smaller, more selective funnel - a targeted early-career program plus off-campus and referral hiring - not a multi-thousand-seat placement drive. Verify any specific college-drive or headcount claim with your placement cell or Intuit’s own careers page.
How should I prepare for Intuit interviews?
Drill medium DSA (arrays, trees, graphs, and O(1) data-structure design), revise OOPs/DBMS/OS fundamentals, and practice reading and extending someone else’s codebase quickly and cleanly - that’s exactly what the Craft Demo tests. For behavioral rounds, prepare STAR stories mapped to Intuit’s operating values (Customer Obsession, Courage, Integrity without Compromise) and be ready to describe a time you validated an idea with real users before building it (Design for Delight).
What is Intuit’s craft / build demonstration?
It is a practical round where you implement features in a real-ish codebase or a timed Java build challenge, then face a deep dive on concurrency, tests, and trade-offs. Treat it like production craft, not a LeetCode paste.
What interviewers score
| Stage | Strong signal | Weak signal |
|---|---|---|
| Online coding | Medium DSA under timer with tests | Untimed grind; no complexity talk |
| Build / craft demo | Working feature + trade-offs + tests | Buzzword design without bottlenecks |
| Technical deep dive | Defend concurrency, edge cases, metrics | Cannot explain your own submission |
| HR / values | Design for Delight + customer-impact STAR | Generic fintech praise with no customer story |
Intuit weighs customer outcome and craft. Financial correctness, idempotency, and seasonal load show up in design talks more than social-feed templates.
Red flags that kill Intuit offers
- Build challenge code you cannot defend in the deep-dive
- Ignoring customer impact in behavioural stories
- System design without consistency/idempotency for money-adjacent flows
- “Why Intuit?” that never mentions TurboTax/QuickBooks/customer problems
- Zero questions about craft expectations or team rituals
How to prepare for Intuit interviews
- Loop map: Recruiter screen; Online Assessment; Technical interview(s); Craft Demo (SDE-2+ / senior). Confirm timings from the drive mail.
- Technical depth: Drill the Q&A section until answers are spoken, not read. Know every resume project cold.
- Experiences: Study round-wise notes on the interview experience page - real prompts beat generic lists.
- HR: Three STAR stories + a specific “Why Intuit?” on the HR page.
Who usually fits and who struggles
Good fit: You already solve LeetCode mediums under a timer, you can narrate trade-offs on a simple distributed design, and you have 1-2 projects with real metrics. Off-campus candidates who can ship a small OOP app with DB + tests in a few hours have a clear edge.
Harder path: You only practiced untimed problems; you freeze on “why this data structure?”; your system-design prep is buzzwords without bottlenecks; you have never written unit tests for a personal project.
A practical Intuit prep plan
Use this as a default four-week loop before a Intuit drive. Adjust to your invite timeline.
- Week 1: Oa pattern first: sit one untimed paper, then redo it under the real clock. Open the Intuit previous-year sets on this site and mark which sections ate your time. Write the timing on a sticky note. That number is more useful than a 200-problem LeetCode streak you never timed.
- Week 2: Most Intuit drives fail people on the first timed paper or OA. Do three timed sits this week. After each one, log every miss in a two-column note: topic and why (slow, wrong formula, bad edge case, panic). The next sit should only add problems from that log.
- Week 3: Technical interviews at Intuit usually want a clean project story, one or two CS fundamentals, and (if the process has it) a behavioral or values round. Write STAR stories on paper, not in your head. Practise “Why Intuit?” with one concrete product, lab, or business line - not a slogan.
- Week 4: Star stories + one project walkthrough recorded on your phone. If you still have energy, redo only the questions you failed in week 2.
10-day crash version: Days 1-4 timed DSA, days 5-7 resume projects + CS fundamentals, days 8-9 mock interviews out loud, day 10 HR STAR stories on the HR page.
Compensation notes
Candidate-reported fresher/early-career packages for Intuit often cite ₹30-40 LPA CTC (Software Engineer). Treat forum numbers as ranges, not guarantees - confirm the written offer letter for your team and location.
Sources
Interview process details and sample questions on this site are editorially organized from public candidate reports and hiring write-ups, with round structure, prep notes, and company-specific framing added by our team. For round-by-round stories, see the Intuit interview experience page. For OA papers and coding drills, use Intuit on placementpapers.app. OA quick answers and level-wise questions draw on Glassdoor candidate reviews for Intuit Bengaluru (2024-2026), LeetCode Discuss Intuit SDE-1 and SSE posts, Naukri Code360 Intuit interview experiences and the Roundz Intuit SDE-1 write-up.