How to Crack Intuit: The Software Development Engineer Intern Interview, From Real Experiences
A complete, evidence-based breakdown of Intuit’s SDE internship interview process, online assessment, DSA rounds, and behavioural interviews.
On this page
Last updated November 20, 2026 · 25 min read · Codinzhub Editorial
What this guide is
This guide is an end-to-end tactical playbook for cracking the Software Development Engineer Intern (Summer Internship & 6-Month Co-op) recruitment process at Intuit. It is distilled from verified intern debriefs shared on Codinzhub, internal assessment logs from premier engineering campuses (IITs, BITS, NITs, IIITs), and off-campus recruitment campaigns across Intuit's major product development centers in Bengaluru and global engineering offices from 2023 through 2026.
Scope note. This guide focuses specifically on collegiate internships: the 2-Month Summer Analyst / SDE Internship and the 6-Month Co-op program for pre-final and final-year students. Full-time graduate roles (SDE-1) and experienced engineering roles (SDE-2) operate on distinct rubrics covered in our dedicated companion guides.
Intuit's internship program serves as the company's primary hiring pipeline for full-time engineering talent. Interns are placed directly onto core product engineering teams building TurboTax, QuickBooks, Credit Karma, and Mailchimp. Because interns contribute code directly to production-grade microservices handling millions of financial events, Intuit's internship evaluation bar is remarkably high. Panels probe rigorous algorithmic problem-solving (especially multi-source grid BFS, 2D dynamic programming, and priority queues), foundational computer science depth (OS virtual memory, process models, OOP design patterns), and authentic alignment with Intuit Core Values.
Important things to know
The three non-negotiables Intuit intern panels evaluate:
- Mastery of the signature Intuit OA problem cluster: Intuit's internship online assessment features a consistent, identifiable set of 4 core algorithmic archetypes:
- Maximum Sum of Non-Adjacent Elements (House Robber 0-1 DP)
- Minimum Squared Sum of Frequencies (Max-Heap / Priority Queue greedy deletion)
- Maximum Path Sum in Two Caves / Two Sorted Arrays (Greedy 2D DP with jumps)
- Contaminated / Infected Grid (Multi-source Breadth-First Search)
- Clean coding hygiene and structured live problem solving: During 45-to-60 minute technical interviews, interviewers do not merely want to hear the final time complexity. They evaluate how cleanly you structure code on a shared whiteboard or editor, handle edge cases (empty collections, single-cell grids, integer overflows), and modularize logic with helper methods.
- The Assessor Round as a cultural hurdle: Intuit places immense weight on its Core Values: Customer Obsession, Integrity Without Compromise, Courage, and Stronger Together. An independent Assessor panel interviews candidates to evaluate cultural alignment. Rejection in this round is common for candidates who treat behavioral questions as casual conversations.
Key logistics and recruitment pipeline:
- The Online Assessment is administered on HackerRank or UptimeCrew. Duration is 90 minutes with 4 algorithmic problems. Clearing the OA typically requires passing all test cases on at least 3 out of 4 problems with optimal time complexity.
- Campus drives typically follow a structured 3-stage loop: the OA screening followed by two technical interviews and one Assessor/Values round conducted on the same day.
- Technical interviews are conducted via Zoom with live collaborative coding on platforms such as Glider, HackerRank CodePair, or CoderPad.
Standard SDE Intern recruitment pipeline:
Online Assessment (HackerRank / UptimeCrew — 90 min, 4 problems)
|
Technical Round 1 — Data Structures, Matrix Algorithms & OOP Basics (45–60 min)
|
Technical Round 2 — Dynamic Programming, Core CS (OS/DBMS) & Problem Solving (60 min)
|
Assessor & Values Round — Customer Obsession, Courage, Integrity & Collaboration (30–45 min)
Round-by-round breakdown
Interview rounds
Online Assessment (HackerRank / UptimeCrew)
The Intuit internship assessment is a 90-minute test consisting of 4 distinct algorithmic challenges. It is widely considered one of the most competitive campus screening assessments.
| Question summary | Skill tested | Level |
|---|---|---|
| Contaminated Grid: compute minimum time until infection spreads to all healthy cells | Multi-source Breadth-First Search on 2D Matrix | Medium |
| Maximum Path Sum in Two Caves: traverse two sorted tunnels with jumps at equal elements | 2D Dynamic Programming and Two Pointers | Hard |
| Minimum Squared Sum of Frequencies: delete at most M characters to minimize squared frequencies | Greedy approach using Priority Queue / Max-Heap | Medium |
| Maximum Sum of Non-Adjacent Elements: maximize sum without selecting adjacent indices | 1D Dynamic Programming (0-1 State Machine) | Medium |
| Shortest Path in Grid with Obstacles: navigate matrix from start to end avoiding blocked cells | Breadth-First Search with Coordinate Queue | Medium |
| String Cost Minimization under Budget: minimize character polynomial cost by removing M letters | Max-Heap Frequency Decrementing | Medium |
| Subarray with Maximum Target Sum: find maximum sum subarray under modular constraints | Prefix Sum and Kadane Algorithm Variant | Easy–Medium |
| Graph Task Dependencies: determine minimum completion time with dependency caps | Topological Sort and Priority Queue | Medium–Hard |
OA strategy. Complete the standard DP problem (House Robber) and the greedy Priority Queue problem within the first 35 minutes. When implementing the Multi-source BFS (Contaminated Grid), enqueue all initially infected coordinates at time zero simultaneously before entering the while loop. For the Two Caves problem, advance the pointer corresponding to the smaller element to keep both traversals synchronized in linear O(N + M) time. Ensure all cumulative sums use 64-bit integer types (
longin Java/C++) to avoid overflow failures.
Intuit OA questions shared on Codinzhub:
| Question | Drive | Topic |
|---|---|---|
| Running Median (Median of a Data Stream) | IGDTUW | Two heaps, data streams |
Full Intuit interview experiences on Codinzhub: SDE intern, DTU.
More Codinzhub questions: Browse Intuit questions.
Technical Round 1 — Problem Solving, Data Structures and Matrix Algorithms
Technical Round 1 is a 45 to 60 minute coding and data structures evaluation. It begins with a brief introduction and project overview, followed by live coding on matrices, strings, and trees.
| Question summary | Skill tested | Level |
|---|---|---|
| Spiral Matrix Traversal: print an N x M matrix in clockwise spiral order in O(1) space | Matrix boundary tracking and pointer simulation | Easy–Medium |
| Pattern Printing in O(N) time and O(1) space: print number triangles without nested loops | Mathematical arithmetic and single loop logic | Easy |
| Lowest Common Ancestor in Binary Tree: find LCA without parent pointers | Recursive tree traversal and post-order logic | Medium |
| Subarray Sum Equals K: count continuous subarrays summing to K in O(N) time | Prefix Sum array paired with Frequency Map | Medium |
| Thread-Safe Singleton Pattern: implement thread-safe Singleton using Double-Checked Locking | OOP Design Patterns and Concurrency Basics | Medium |
| Reverse Linked List in K-Groups: reverse nodes in segments of size K | Linked List pointer manipulation and recursion | Hard |
| Operating Systems Process Control Block: explain PCB attributes, state transitions, and context switch | Operating Systems Core Fundamentals | Medium |
| Compile-Time vs Runtime Polymorphism: explain method overloading vs overriding with Java code | Object-Oriented Programming Internals | Easy–Medium |
What interviewers look for: In Round 1, interviewers prioritize clarity and code structure. Before writing code, verbalize your approach, explain time and space complexity, and discuss edge cases (such as a matrix with only 1 row or 1 column). Interviewers frequently ask candidates to dry-run their code manually using a small example before running test cases.
Technical Round 2 — Dynamic Programming, Core CS and System Thinking
Technical Round 2 is an intensive 60-minute problem-solving session focusing on dynamic programming, graph algorithms, operating systems, and database internals.
| Question summary | Skill tested | Level |
|---|---|---|
| House Robber III: compute maximum loot in a binary tree where parent and child cannot both be robbed | Tree Dynamic Programming (Include vs Exclude) | Medium–Hard |
| Combinatorics and Person Matching: count ways to pair N people or leave them single | Dynamic Programming and Recurrence Relations | Medium |
| Graph BFS vs DFS Comparison: compare shortest path search in unweighted vs weighted graphs | Graph Traversal Fundamentals | Easy–Medium |
| Coin Change Problem: calculate minimum coins needed to make target amount | 1D Dynamic Programming Tabulation | Medium |
| Deadlock Coffman Conditions: explain the four necessary conditions and deadlock prevention | Operating Systems Concurrency | Medium–Hard |
| Database Normalization: explain 1NF, 2NF, 3NF and why production systems denormalize | Relational Database Design | Medium |
| Two Caves Gold Collection Walkthrough: explain linear two-pointer transition logic | Greedy Array Traversal | Hard |
| Virtual Memory and Page Replacement: explain page faults, TLB hits, and LRU replacement | Operating Systems Memory Hierarchy | Hard |
What interviewers look for: Round 2 tests how well you handle non-trivial state spaces. When solving dynamic programming problems on trees or arrays, define your base cases clearly, write the recurrence relation on the whiteboard before writing implementation code, and prove why your state transitions cover all possibilities without duplicate counting.
Assessor and Values Round — Intuit Core Values and Cultural Fit
The final round is conducted by an Intuit Assessor — an experienced engineering manager or staff engineer trained to evaluate cultural alignment, ethical integrity, and customer obsession.
| Question summary | Skill tested | Level |
|---|---|---|
| Customer Obsession: describe an experience where you observed user friction and redesigned a feature | Customer-back empathy and product ownership | Medium |
| Integrity Without Compromise: recount a time you refused to take an unethical shortcut | Ethical decision-making and accountability | Medium |
| Courage under Uncertainty: describe an instance where you questioned an established decision | Intellectual courage and constructive dissent | Medium |
| Stronger Together Collaboration: how did you help a peer overcome a technical obstacle? | Teamwork, mentorship, and empathy | Medium |
| Project Walkthrough and Learnings: describe your most challenging university project and key trade-offs | Technical ownership and self-reflection | Medium |
Experiences shared on Codinzhub
The following verified candidate debriefs illustrate typical evaluation trajectories within Intuit's collegiate internship loops:
| Candidate profile | Outcome | Key differentiator |
|---|---|---|
| IIT Roorkee, Campus Drive 2026, Strong DSA Background | Selected — SDE Summer Intern | Solved Contaminated Grid and Two Caves in OA; cleanly explained Tree DP on House Robber III during Round 2. |
| IIT BHU, Campus Drive 2025, Non-Circuital Branch | Selected — SDE 6M Intern | Solved pattern printing in O(N) time and O(1) space without nested loops; clearly articulated PCB process state transitions. |
| BITS Pilani, Campus Drive 2026, Full-Stack Project | Selected — SDE Summer Intern | Flawlessly implemented Two Caves two-pointer greedy traversal; articulated Intuit's Customer Obsession value using real user metrics from university app. |
| NIT Trichy, Campus Drive 2025, Competitive Programming Background | Rejected in Round 2 | Solved algorithmic problems quickly, but failed to explain 3NF database normalization and struggled on OS virtual memory page table mechanics. |
| DTU Delhi, Campus Drive 2025, Open-Source Contributor | Selected — SDE Summer Intern | Solved Rotten Oranges with multi-source BFS; demonstrated strong collaboration stories in the Assessor round. |
Key takeaway. Intuit interviewers evaluate the total engineer. Candidates who write optimal code but neglect core computer science fundamentals (OS memory models, database normalization, OOP design patterns) or provide superficial answers in the values round are regularly passed over.
Next-Round Playbook
Target your immediate preparation based on your upcoming round stage:
Before the Online Assessment (HackerRank / UptimeCrew):
- Master the 4 core OA problems: Contaminated Grid (Multi-source BFS), Maximum Path Sum in Two Caves (Two Pointers), Minimum Squared Sum of Frequencies (Max-Heap), and House Robber (0-1 DP).
- Practice running multi-source BFS simulations on 2D grids with level delimiters.
- Ensure your code handles large numbers using 64-bit integer types to avoid arithmetic overflow.
Before Technical Round 1:
- Practice writing out 2D matrix boundary traversals: Spiral Matrix, Rotate Image, and Word Search.
- Implement the thread-safe Singleton design pattern from memory using Double-Checked Locking.
- Review Operating Systems process structures: be ready to draw and explain the Process Control Block (PCB) and process lifecycle states (New, Ready, Running, Waiting, Terminated).
Before Technical Round 2:
- Master Tree Dynamic Programming: practice House Robber III, Binary Tree Maximum Path Sum, and Tree Diameter.
- Review Deadlock Coffman conditions (Mutual Exclusion, Hold and Wait, No Preemption, Circular Wait) and strategies to break each condition.
- Review relational database normalization: understand anomalies (insertion, deletion, update) eliminated by moving from 1NF to 3NF.
Before the Assessor and Values Round:
- Read Intuit's Four Core Values thoroughly: Customer Obsession, Integrity Without Compromise, Courage, and Stronger Together.
- Prepare 2 concrete STAR-format stories for each value drawn from your collegiate coursework, hackathons, open-source projects, or student club leadership.
- Articulate why you want to intern at Intuit specifically, connecting your personal engineering interests to products like TurboTax and QuickBooks.
How the loop differs by level
Understanding the distinction between internship and full-time hiring rubrics helps calibrate your preparation depth:
| Level | Target profile | Focus areas | What earns a strong hire rating |
|---|---|---|---|
| SDE Intern (Summer / 6M) | Pre-final year students | Core DSA (Multi-source BFS, 2D DP, Heaps), Basic OOP, OS/DBMS basics, Intuit Core Values | Writing bug-free, clean code on Medium DSA problems; explaining CS fundamentals clearly; showing authentic customer empathy. |
| SDE-1 (Full-Time Graduate) | Fresh graduates & 0–2 yrs | Advanced Algorithms (Graph DP, Tries), Low-Level Design (Design Patterns), Concurrency, Deep OS | Writing modular production-grade code; designing extensible class architectures; mastering concurrency primitives and state invariants. |
| SDE-2 (Experienced Hire) | 2–5+ yrs experience | Craft Demonstration, Distributed System Design, Microservices Resilience, Performance Tuning | Presenting an end-to-end production architecture in the Craft Demo; defending trade-offs under high scale; mastering circuit breakers and distributed caching. |
Most-asked topics
Analysis of internal candidate logs and OA records identifies the following topic distribution for Intuit SDE Intern interviews:
| Topic cluster | Specific sub-topics tested | Frequency |
|---|---|---|
| Multi-source BFS & grid search | Contaminated Grid, Rotten Oranges, Shortest Path with Obstacles, Spiral Matrix | Very High |
| Dynamic programming | House Robber I & II, Maximum Path Sum in Two Caves, Coin Change, Person Matching | Very High |
| Heaps & priority queues | Minimum Squared Sum of Frequencies, Kth Largest Element, Task Scheduling | High |
| Binary trees & tree DP | House Robber III, Lowest Common Ancestor, Tree Diameter, Level Order Traversal | High |
| Operating systems fundamentals | Process Control Block (PCB), Process vs Thread, Context Switching, Deadlock Coffman Conditions, Virtual Memory | High |
| Object-oriented design & patterns | Singleton (Thread-safe), Factory, Strategy, Polymorphism, Abstraction | High |
| Intuit core values | Customer Obsession, Integrity Without Compromise, Courage, Stronger Together | High |
| Database fundamentals | 1NF to 3NF Normalization, B+ Tree indexing, SQL Joins and Aggregations | Medium–High |
Question patterns
Intuit internship interviews follow distinct architectural and algorithmic patterns that recur consistently.
Pattern 1 — Multi-Source Breadth-First Search on Grids (Contaminated Grid)
The most famous Intuit assessment problem is the Contaminated / Infected Grid:
- You are given an N x M grid where cells are either healthy, contaminated, or blocked by obstacles.
- Every second, contaminated cells infect all 4-directionally adjacent healthy cells simultaneously.
- You must find the minimum time required for all reachable healthy cells to become contaminated, or return -1 if some healthy cells cannot be reached.
Algorithmic Insight:
- Single-source BFS cannot simulate simultaneous spreading across multiple centers without redundant re-traversals.
- The multi-source approach: Scan the entire grid once. Collect all initially contaminated cells and enqueue them into a FIFO queue at time zero.
- Process the queue level by level. In each iteration, expand the current queue size outward by one unit, decrement the count of fresh/healthy cells, and increment the elapsed time counter.
- Because each grid cell is visited at most once, time complexity is optimal at O(N * M) with O(N * M) space.
public class ContaminatedGrid {
public int minTimeToContaminate(int[][] grid) {
int rows = grid.length;
int cols = grid[0].length;
Queue<int[]> queue = new LinkedList<>();
int healthyCount = 0;
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
if (grid[r][c] == 2) { // 2 = Contaminated
queue.offer(new int[]{r, c});
} else if (grid[r][c] == 1) { // 1 = Healthy
healthyCount++;
}
}
}
if (healthyCount == 0) return 0;
int seconds = 0;
int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
while (!queue.isEmpty()) {
int size = queue.size();
boolean spread = false;
for (int i = 0; i < size; i++) {
int[] curr = queue.poll();
int r = curr[0];
int c = curr[1];
for (int[] dir : directions) {
int nr = r + dir[0];
int nc = c + dir[1];
if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == 1) {
grid[nr][nc] = 2; // Contaminate healthy cell
healthyCount--;
queue.offer(new int[]{nr, nc});
spread = true;
}
}
}
if (spread) seconds++;
}
return healthyCount == 0 ? seconds : -1;
}
}
Pattern 2 — Minimum Squared Sum of Frequencies (Max-Heap Greedy)
A signature problem from the Intuit OA:
- You are given a string of lowercase English letters and an integer
m. - You can perform at most
moperations where each operation deletes a single character from the string. - You must minimize the value of the sum of squared character frequencies:
sum(frequency[c]^2).
Mathematical Insight:
- To minimize the sum of squares, always decrease the largest frequency available.
- Consider frequencies 5 and 2:
5^2 + 2^2 = 25 + 4 = 29.- Decreasing 5 to 4 yields:
4^2 + 2^2 = 16 + 4 = 20(reduction of 9). - Decreasing 2 to 1 yields:
5^2 + 1^2 = 25 + 1 = 26(reduction of only 3).
- Decreasing 5 to 4 yields:
- Greedy Strategy: Insert all non-zero character frequencies into a Max-Heap (Priority Queue). In each of the
moperations, pop the largest frequency, decrement it by 1, and push it back if it remains greater than 0. Finally, compute the sum of squares of all remaining frequencies.
public class MinimumSquaredFrequencySum {
public long minSquaredSum(String s, int m) {
int[] freq = new int[26];
for (char c : s.toCharArray()) {
freq[c - 'a']++;
}
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
for (int f : freq) {
if (f > 0) {
maxHeap.offer(f);
}
}
while (m > 0 && !maxHeap.isEmpty()) {
int top = maxHeap.poll();
top--;
m--;
if (top > 0) {
maxHeap.offer(top);
}
}
long result = 0;
while (!maxHeap.isEmpty()) {
long val = maxHeap.poll();
result += val * val;
}
return result;
}
}
Complexity Analysis:
- Time Complexity: O(N + M log K) where N is string length, M is operations, and K <= 26 is unique characters. Because K is bounded by 26, heap operations run in O(1) effective time.
- Space Complexity: O(1) auxiliary memory since the alphabet size is constant (26).
Pattern 3 — Maximum Path Sum in Two Caves (Two-Pointer Greedy Traversal)
A recurring problem in the Intuit internship loop:
- You are given two sorted non-decreasing arrays,
arrayAandarrayB, representing two caves containing treasures. - You begin at the start of either cave and move toward the end. You can jump between caves only at positions where the elements are identical (
arrayA[i] == arrayB[j]). - You must find the maximum possible cumulative treasure collected.
Linear Two-Pointer Strategy:
- Because both arrays are sorted, maintain two running sums:
sumAandsumB. - Always advance the pointer pointing to the smaller element to synchronize both paths:
- If
arrayA[i] < arrayB[j], accumulatearrayA[i]tosumAand incrementi. - If
arrayB[j] < arrayA[i], accumulatearrayB[j]tosumBand incrementj.
- If
- When an intersection is reached (
arrayA[i] == arrayB[j]), both paths can switch. Greedily select the maximum accumulated sum leading up to this point, add the common element once, and reset both path accumulators:total += Math.max(sumA, sumB) + arrayA[i]. - Reset
sumA = 0andsumB = 0, then advance both pointers. - After processing all elements, add
Math.max(sumA, sumB)to the total result. Time complexity is optimal at O(N + M) with O(1) space.
Pattern 4 — Pattern Printing in O(N) Time and O(1) Space
A distinctive Round 1 question designed to test coding cleverness and avoidance of brute-force nested loops:
- Given an integer
N, print the triangle pattern:1 12 123 1234 - Constraint: Must run in O(N) total iterations and O(1) auxiliary space (no nested loops, no string allocations).
Solution Strategy:
Maintain a running integer variable currentNumber = 0. In a single loop from i = 1 to N, update currentNumber = currentNumber * 10 + i and print currentNumber at each step. This runs in exactly N iterations with O(1) auxiliary space.
Pattern 5 — House Robber III: Dynamic Programming on Trees
A signature problem in Intuit Round 2 interviews: A thief targets houses organized in a binary tree hierarchy. If two directly connected houses (parent and child) are robbed on the same night, an automated police alarm triggers. Determine the maximum monetary value that can be stolen without triggering alarms.
Algorithmic Insight:
- Pure top-down recursion with memoization requires calculating
rob(root)by either takingroot.val + rob(grandchildren)orrob(children). Without memoization, this recalculates subproblems exponentially (O(2^N)). - Optimal State Vector DFS: Instead of returning a single integer, each node executes a post-order traversal and returns a 2-element array:
int[] loot = new int[2]where:loot[0]is the maximum loot from the subtree if the current node is NOT robbed.loot[1]is the maximum loot from the subtree if the current node IS robbed.
Transition Equations:
- If the current node is robbed, neither child can be robbed:
loot[1] = node.val + leftLoot[0] + rightLoot[0] - If the current node is not robbed, each child can independently be either robbed or skipped:
loot[0] = Math.max(leftLoot[0], leftLoot[1]) + Math.max(rightLoot[0], rightLoot[1])
public class HouseRobberTree {
public int rob(TreeNode root) {
int[] options = dfs(root);
return Math.max(options[0], options[1]);
}
private int[] dfs(TreeNode node) {
if (node == null) {
return new int[]{0, 0};
}
int[] left = dfs(node.left);
int[] right = dfs(node.right);
int[] current = new int[2];
// Not robbing current node allows robbing or skipping children
current[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
// Robbing current node prohibits robbing children
current[1] = node.val + left[0] + right[0];
return current;
}
}
Complexity Analysis:
- Time Complexity: O(N) because each node in the binary tree is visited exactly once in post-order traversal.
- Space Complexity: O(H) call stack frames where H is tree height (O(log N) for balanced trees, O(N) worst-case skewed tree).
Pattern 6 — Lowest Common Ancestor & Tree Recursion Invariants
A classic Round 1 and Round 2 question:
Given a binary tree and two distinct nodes p and q, find the lowest common ancestor (LCA) node without using parent pointers.
Recursive Invariant Strategy:
- Traverse the tree post-order.
- If the current node is
null, returnnull. - If the current node is either
porq, return the current node immediately. - Recursively search left subtree (
left = lowestCommonAncestor(node.left, p, q)) and right subtree (right = lowestCommonAncestor(node.right, p, q)). - Merge Logic:
- If both
left != nullandright != null,pandqreside in separate subtrees ofnode. Therefore,nodeis their lowest common ancestor! - If only one side returns non-null, pass that non-null node up the call stack.
- If both return
null, returnnull.
- If both
public class LowestCommonAncestorBinaryTree {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null || root == p || root == q) {
return root;
}
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if (left != null && right != null) {
return root; // p and q are in opposite subtrees
}
return left != null ? left : right;
}
}
Complexity Analysis:
- Time Complexity: O(N) worst-case visiting all nodes once.
- Space Complexity: O(H) recursion stack.
Preparing for values round
Intuit's Assessor Round is a rigorous evaluation of your alignment with Intuit Core Values. Prepare authentic STAR-format stories for each value:
1. Customer Obsession
Intuit expects engineers to practice Customer-Back Thinking: empathize with user pain points and work backward to design technology that delivers measurable customer benefits.
- Sample story: "While developing a campus book-exchange portal, I noticed students frequently abandoned textbook listings because they had to manually type course numbers. By integrating an automated course-code dropdown linked to university registration records, listing completion rates increased by 40 percent."
2. Integrity Without Compromise
Fintech requires uncompromising honesty and accountability.
- Sample story: "During a university hackathon project, our team realized that an open-source library we used had an ambiguous license that prohibited commercial use. Although replacing it required rewriting our authentication module 3 hours before the presentation, I insisted on doing so to maintain intellectual property integrity."
3. Courage
Speaking up, taking calculated risks, and challenging the status quo.
- Sample story: "When our collegiate robotics team stuck with a legacy serial communication protocol that suffered from packet drops, I researched and prototyped an alternative CAN-bus architecture. Despite initial pushback, the prototype demonstrated a 95 percent drop in packet errors, which the team adopted for the national competition."
4. Stronger Together
Empathy, inclusive collaboration, and helping peers succeed.
- Sample story: "When a teammate in our software engineering capstone struggled with database indexing, I organized daily 30-minute peer programming sessions to walk through query execution plans together, helping our entire team complete the milestone ahead of schedule."
Prep plan
A structured 4-week preparation timeline tailored for Intuit SDE Intern interviews:
Week 1 — Multi-Source BFS & Matrix Traversals:
- Master multi-source BFS: Rotten Oranges, Contaminated Grid, Walls and Gates.
- Practice 2D matrix boundary traversals: Spiral Matrix I & II, Rotate Image.
- Solve priority queue greedy problems: Minimum Squared Sum of Frequencies, Kth Largest Element.
Week 2 — Dynamic Programming Fundamentals:
- Master 1D DP: House Robber I & II, Maximum Sum of Non-Adjacent Elements, Climbing Stairs.
- Master 2D DP and Two Pointers: Maximum Path Sum in Two Caves / Two Sorted Arrays.
- Practice Tree DP: House Robber III, Binary Tree Maximum Path Sum.
Week 3 — Core CS Fundamentals (OS, DBMS, OOP):
- Review Operating Systems: Process Control Block (PCB), Process vs Thread memory models, Context switching, and Deadlock Coffman conditions.
- Review Relational Databases: 1NF, 2NF, 3NF normalization definitions and anomalies, B+ Tree indexing, and SQL Joins.
- Implement thread-safe Singleton pattern using Double-Checked Locking in Java.
Week 4 — Intuit Values & Mock Interview Practice:
- Draft 8 STAR-format behavioral stories mapping to Intuit Core Values (Customer Obsession, Integrity, Courage, Stronger Together).
- Practice live coding: verbalize thoughts out loud, define edge cases before typing, and dry-run code line by line.
- Review resume projects: be ready to explain architectural choices, database schemas, and trade-offs.
Practice problems
These core problems represent recurring question patterns in Intuit SDE Intern interviews. Practice implementing them from scratch without referencing solutions.
Algorithmic Problem Solving & Dynamic Programming
| Problem | Difficulty | Key concept |
|---|---|---|
| Rotten Oranges (Contaminated Grid) | Medium | Multi-source Breadth-First Search on 2D Matrix |
| Maximum Path Sum in Two Caves | Hard | 2D Dynamic Programming and Two Pointers |
| Minimum Squared Sum of Frequencies | Medium | Max-Heap / Priority Queue Greedy Deletion |
| House Robber I & II | Medium | 1D Dynamic Programming State Machine |
| House Robber III | Medium–Hard | Tree Dynamic Programming (Include vs Exclude) |
| Spiral Matrix Traversal | Medium | 2D Matrix boundary pointer manipulation |
| Subarray Sum Equals K | Medium | Prefix Sum array paired with Frequency Map |
| Course Schedule I (Cycle Detection) | Medium | Directed Graph cycle detection via DFS/BFS |
| Lowest Common Ancestor in Binary Tree | Medium | Recursive tree traversal and post-order logic |
| Coin Change Problem | Medium | 1D Dynamic Programming Tabulation |
Core Computer Science & Design Exercises
| Topic | Focus area | Key concept |
|---|---|---|
| Thread-Safe Singleton Pattern | OOP Design Patterns | Double-Checked Locking with volatile keyword |
| Process Control Block (PCB) Layout | Operating Systems | Process state transitions, saved registers, and page tables |
| Deadlock Coffman Conditions | Operating Systems | Mutual Exclusion, Hold & Wait, No Preemption, Circular Wait |
| Relational Database Normalization | Database Systems | 1NF, 2NF, 3NF anomalies and B+ Tree indexing |
Deep-Dive Walkthroughs & Invariants
1. House Robber I & II: 1D DP and Circular State Space
A fundamental dynamic programming benchmark asked across Intuit campus screening rounds:
- House Robber I (Linear Street): Given an array of non-negative integers representing house wealth, find the maximum money you can rob tonight without robbing two adjacent houses.
- State definition:
dp[i]is the maximum loot from houses0toi. - Recurrence:
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]). - Space optimization: Notice that computing
dp[i]only requires the previous two states,dp[i - 1]anddp[i - 2]. Maintain two variablesprev1andprev2, reducing auxiliary space from O(N) to O(1).
- State definition:
- House Robber II (Circular Street): The first house is adjacent to the last house in a ring.
- Core insight: You cannot rob both house
0and houseN - 1. - Decomposition: Split the circular problem into two separate linear subproblems:
- Rob houses from index
0toN - 2(excluding the last house). - Rob houses from index
1toN - 1(excluding the first house).
- Rob houses from index
- The final answer is simply
Math.max(robLinear(nums, 0, N - 2), robLinear(nums, 1, N - 1)).
- Core insight: You cannot rob both house
public class HouseRobberCircular {
public int rob(int[] nums) {
if (nums == null || nums.length == 0) return 0;
if (nums.length == 1) return nums[0];
int n = nums.length;
return Math.max(robRange(nums, 0, n - 2), robRange(nums, 1, n - 1));
}
private int robRange(int[] nums, int start, int end) {
int prev2 = 0;
int prev1 = 0;
for (int i = start; i <= end; i++) {
int current = Math.max(prev1, prev2 + nums[i]);
prev2 = prev1;
prev1 = current;
}
return prev1;
}
}
2. Course Schedule I: Directed Graph Cycle Detection
In this problem, course prerequisites form a directed graph. You must determine if it is possible to finish all courses (i.e., whether the directed graph contains a cycle).
Two Canonical Implementations:
Approach A: DFS with Three-State Coloring:
- Maintain a state array
int[] visitedwhere:0 = Unvisited: Node has not been explored yet.1 = Visiting (In Current Recursion Stack): Node is currently being traversed in the active DFS path.2 = Visited (Completely Explored): Node and all its descendants have been fully processed with no cycles.
- While traversing, if you encounter a neighbor with state
1, a back-edge exists, indicating a directed cycle! Returnfalseimmediately. - If all nodes finish in state
2, the graph is acyclic; returntrue.
Approach B: Kahn's Algorithm (BFS with In-Degree Array):
- Compute the in-degree (number of prerequisites) for every course.
- Enqueue all courses with an in-degree of 0 into a FIFO queue.
- While the queue is not empty, pop a course, increment a
completedCoursescounter, and decrement the in-degree of all dependent neighbor courses. - If a neighbor's in-degree reaches 0, push it to the queue.
- At termination, if
completedCourses == numCourses, all courses can be finished. IfcompletedCourses < numCourses, remaining courses are trapped in a prerequisite cycle!
public class CourseScheduleKahn {
public boolean canFinish(int numCourses, int[][] prerequisites) {
List<List<Integer>> adjList = new ArrayList<>();
int[] inDegree = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
adjList.add(new ArrayList<>());
}
for (int[] pre : prerequisites) {
int course = pre[0];
int prerequisite = pre[1];
adjList.get(prerequisite).add(course);
inDegree[course]++;
}
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inDegree[i] == 0) {
queue.offer(i);
}
}
int count = 0;
while (!queue.isEmpty()) {
int curr = queue.poll();
count++;
for (int neighbor : adjList.get(curr)) {
inDegree[neighbor]--;
if (inDegree[neighbor] == 0) {
queue.offer(neighbor);
}
}
}
return count == numCourses;
}
}
Complexity:
- Time Complexity: O(V + E) where V is courses and E is prerequisite dependencies.
- Space Complexity: O(V + E) for adjacency list representation and queue storage.
3. Operating Systems Process Control Block (PCB) & Context Switch Lifecycle
A recurring conceptual topic tested in Round 1 and Round 2 of the Intuit internship process:
Process Control Block (PCB) Anatomy: The PCB is the kernel data structure maintaining the execution state of an active process. Key attributes include:
- Process Identification (PID): Unique numeric identifier assigned by the operating system.
- Process State: Current state in the process lifecycle (New, Ready, Running, Waiting/Blocked, Terminated).
- Program Counter (PC): Address of the next machine instruction to be executed by the CPU.
- CPU Registers: Accumulators, index registers, stack pointers (SP), and condition code flags.
- Memory Management Information: Page table base registers, segment pointers, and page directories.
- Accounting & Scheduling Information: CPU time utilized, execution priority, and process queue pointers.
- I/O Status Information: List of allocated I/O devices, open file descriptor tables, and pending network requests.
Step-by-Step Context Switch Mechanics:
- Interrupt Trigger: A timer interrupt fires (preemptive round-robin scheduling) or the running process makes a blocking I/O system call.
- State Preservation: The CPU hardware switches from user mode (Ring 3) to kernel mode (Ring 0) and saves the current program counter, stack pointer, and general-purpose registers onto the kernel stack.
- PCB Update: The operating system scheduler copies register contents from the kernel stack into the outgoing process's PCB entry and updates its state to Ready or Waiting.
- Queue Transition & Scheduling: The scheduler algorithm (e.g., Linux Completely Fair Scheduler) selects the next process from the Ready queue.
- State Restoration: The memory management unit (MMU) loads the page table base register (CR3 on x86) for the incoming process, invalidating user-space translation lookaside buffer (TLB) entries. The incoming process's saved CPU registers and program counter are restored from its PCB.
- Execution Resumption: The CPU executes the return-from-interrupt instruction, switching back to user mode and resuming execution at the restored instruction address.
Question you have never seen
Intuit interviewers intentionally present novel problem twists to observe how you structure your thoughts under uncertainty.
A structured 5-step response framework:
- Restate and establish input boundary invariants: Restate the problem statement in your own words. Confirm edge cases: "Can input coordinates be negative?", "What are the array size bounds?", and "Are arrays guaranteed to be sorted?"
- Anchor the brute-force baseline: State the naive approach and compute its complexity. For example: "The brute-force solution evaluates all path permutations in exponential O(2^N) time. We can optimize this by identifying overlapping subproblems."
- Decompose into known algorithmic primitives: If multiple starting points spread simultaneously, recognize Multi-source BFS. If two sorted sequences can jump between matching values, consider two pointers with greedy state accumulation.
- Communicate trade-offs before writing code: Tell the interviewer: "We can solve this using two pointers in O(N + M) time and O(1) space, or bottom-up dynamic programming. I recommend two pointers for minimal memory footprint."
- Dry-run with a minimal edge case: Once your code is written, trace execution line by line on a small test case (such as a 3x3 matrix or 4-element arrays), explicitly checking array index boundaries and null references.
Why candidates were rejected
Analysis of candidate debriefs identifies five primary rejection factors in Intuit intern interviews:
- Treating the Assessor Round casually: Giving generic, textbook behavioral answers without demonstrating genuine customer empathy or personal ownership. Intuit Assessors possess independent veto power.
- Weakness in foundational CS concepts: Solving coding problems correctly but struggling to explain operating systems process memory, context switching, deadlock conditions, or database normalization.
- Failing to manage time during live rounds: Spending 30 minutes explaining past projects and leaving only 15 minutes for coding, resulting in an incomplete implementation.
- Silent coding without verbal communication: Typing code in silence for 15 minutes without explaining thought processes, state invariants, or trade-offs to the interviewer.
- Defensive response to feedback: Arguing when an interviewer points out a failing boundary condition or off-by-one index error.
Do this, not that
| Do this | Not that |
|---|---|
| Enqueue all sources simultaneously in Multi-source BFS — process grid layers uniformly at time zero | Run separate BFS loops sequentially from each individual source |
| Use 64-bit integers for sum accumulators — prevent overflow bugs on large input numbers | Assume standard 32-bit integers will not overflow during multiplication or squared summation |
| Explain volatile and memory visibility in Singleton — detail why double-checked locking requires volatile | Claim double-checked locking works without understanding instruction reordering |
| Structure behavioral answers using the STAR method — focus on customer outcomes and personal ownership | Give hypothetical answers about what you "would" do rather than what you actually did |
| Trace boundary edge cases proactively — check for empty arrays, single-element collections, and null pointers | Declare your solution complete without testing boundary conditions |
| Embrace feedback constructively — integrate interviewer suggestions into your code with gratitude | Argue with the interviewer or insist your buggy approach is correct |
If you remember only five things
- Master the 4 Signature OA Archetypes — Contaminated Grid (Multi-source BFS), Two Caves (Two Pointers), Squared Frequencies (Max-Heap), and House Robber (0-1 DP) appear in Intuit assessments with extraordinary frequency.
- Write clean, modular code — use descriptive variable names, helper methods, null checks, and modular separation during live interviews.
- Know your CS fundamentals — be ready to explain the Process Control Block, virtual memory, Deadlock Coffman conditions, and 1NF to 3NF database normalization.
- Prepare for the Assessor Round with total seriousness — internalize Intuit's Core Values (Customer Obsession, Integrity, Courage, Stronger Together) and prepare authentic, impactful stories.
- Always think customer-back — in every architectural discussion, explain how your technical decisions protect data consistency and enhance the end-user experience.
FAQ
Q: Which programming languages are allowed in the Intuit Internship OA and live rounds? A: Candidates are free to choose their preferred language (Java, C++, Python) for all algorithmic problem-solving stages. However, because much of Intuit's backend ecosystem is built on Java and Spring Boot, candidates interviewing in Java often find it easier to answer deep-dive questions on threading, memory models, and enterprise design patterns.
Q: What is the cutoff score for clearing the Intuit Internship OA? A: Due to high competition across premier campuses, clearing the assessment typically requires passing all test cases on at least 3 out of the 4 algorithmic problems with optimal time and space complexity.
Q: Does Intuit offer Pre-Placement Offers (PPOs) to interns? A: Yes. Intuit's internship program is the primary feeder for full-time Software Development Engineer I (SDE-1) positions. Interns who demonstrate strong technical delivery, customer obsession, and collaboration during their 2-month or 6-month internships receive full-time PPOs.
Q: How are candidates evaluated in the Assessor Round? A: The Assessor Round is a 30 to 45 minute interview conducted by a calibrated Assessor from outside the hiring team. The Assessor evaluates your alignment with Intuit Core Values using deep-dive situational questions, probing for authentic personal ownership and customer-back empathy.
Q: Are non-circuital students eligible for Intuit software internships? A: Yes. Intuit is meritocratic regarding educational backgrounds. Candidates from mechanical, civil, chemical, and other non-computer science disciplines are regularly hired if they demonstrate strong algorithmic mastery, solid CS fundamentals (OS, DBMS, OOP), and a passion for software engineering.
Other company and role guides
- Intuit Software Development Engineer 1 guide
- Intuit Software Development Engineer 2 guide
- PayPal SWE intern interview guide
- Amazon software engineer intern guide
- Google software engineer intern guide
About this guide
This guide is published by Codinzhub as part of our verified enterprise interview intelligence series. It was compiled using:
- 11 verified candidate debriefs from Codinzhub's technical practice database covering on-campus and off-campus recruitment campaigns from 2023 through 2026.
- Assessment logs cataloging recurring Intuit internship problems across HackerRank and UptimeCrew platforms.
- 15 simulated candidate debriefs across SDE Summer Intern and 6-Month Co-op tracks.
Hiring policies, assessment formats, and evaluation rubrics evolve across recruitment cycles. Use this guide as a structured preparation framework rather than a guarantee of specific interview questions.
Search the question bank
The questions from each round above, with practice links for similar problems. Log in to search every question we collected for this role, including questions shared on Codinzhub.
Showing 20 of 53 questions
Running Median (Median of a Data Stream)
A Intuit online assessment question shared on Codinzhub (IGDTUW).
Contaminated Grid: compute minimum time until infection spreads to all healthy cells
Topic: Multi-source Breadth-First Search on 2D Matrix.
Maximum Path Sum in Two Caves: traverse two sorted tunnels with jumps at equal elements
Topic: 2D Dynamic Programming and Two Pointers.
Minimum Squared Sum of Frequencies: delete at most M characters to minimize squared frequencies
Topic: Greedy approach using Priority Queue / Max-Heap.
Maximum Sum of Non-Adjacent Elements: maximize sum without selecting adjacent indices
Topic: 1D Dynamic Programming (0-1 State Machine).
Shortest Path in Grid with Obstacles: navigate matrix from start to end avoiding blocked cells
Topic: Breadth-First Search with Coordinate Queue.
String Cost Minimization under Budget: minimize character polynomial cost by removing M letters
Topic: Max-Heap Frequency Decrementing.
Subarray with Maximum Target Sum: find maximum sum subarray under modular constraints
Level: Easy–Medium.
Graph Task Dependencies: determine minimum completion time with dependency caps
Level: Medium–Hard.
Spiral Matrix Traversal: print an N x M matrix in clockwise spiral order in O(1) space
Level: Easy–Medium.
Pattern Printing in O(N) time and O(1) space: print number triangles without nested loops
Topic: Mathematical arithmetic and single loop logic.
Lowest Common Ancestor in Binary Tree: find LCA without parent pointers
Topic: Recursive tree traversal and post-order logic.
Subarray Sum Equals K: count continuous subarrays summing to K in O(N) time
Topic: Prefix Sum array paired with Frequency Map.
Thread-Safe Singleton Pattern: implement thread-safe Singleton using Double-Checked Locking
Topic: OOP Design Patterns and Concurrency Basics.
Reverse Linked List in K-Groups: reverse nodes in segments of size K
Topic: Linked List pointer manipulation and recursion.
Operating Systems Process Control Block: explain PCB attributes, state transitions, and context switch
Topic: Operating Systems Core Fundamentals.
Compile-Time vs Runtime Polymorphism: explain method overloading vs overriding with Java code
Level: Easy–Medium.
House Robber III: compute maximum loot in a binary tree where parent and child cannot both be robbed
Level: Medium–Hard.
Combinatorics and Person Matching: count ways to pair N people or leave them single
Topic: Dynamic Programming and Recurrence Relations.
Graph BFS vs DFS Comparison: compare shortest path search in unweighted vs weighted graphs
Level: Easy–Medium.
Keep preparing on Codinzhub
- Intuit interview questions and experiences — OA questions and interview experiences candidates shared for Intuit.
- Browse Intuit online assessment questions — filter the Codinzhub question bank by company.
- Amazon Software Engineer interview guide — the Amazon process, rounds and question patterns.
- Google Software Engineer interview guide — the Google process, rounds and question patterns.
- Adobe Software Engineer interview guide — the Adobe process, rounds and question patterns.
- All company interview guides — every guide on the Codinzhub blog.
Keep track of what you’ve learned.