Intuit Placement Papers 2026 | Previous Year Questions, Syllabus & Hiring Process

Meta Description: Prepare for Intuit campus placements 2026 with our complete guide. Includes Intuit placement papers, aptitude questions, coding problems, financial software questions, HR interview Q&As, and tips. Freshers package: ₹18–35 LPA.

---

About Intuit: Company Overview

Intuit Inc. is a global financial technology company renowned for building software that simplifies financial management for individuals, small businesses, and accountants. Founded in 1983 by Scott Cook and Tom Proulx, Intuit is headquartered in Mountain View, California, and operates flagship products including TurboTax (personal tax filing), QuickBooks (small business accounting), Credit Karma (personal finance and credit monitoring), and Mailchimp (marketing automation for small businesses). With over $14 billion in annual revenue and 17,000+ employees globally, Intuit's mission is to "Power Prosperity Around the World."

Intuit's India operations are headquartered in Bangalore, which serves as the company's largest engineering center outside the United States. Over 4,000 engineers work from Intuit Bangalore on products used by tens of millions of customers globally. The India center owns significant product areas end-to-end — not just support or maintenance — making it a genuine engineering hub with real ownership and impact. Fresh engineers at Intuit work on AI-driven financial recommendations, real-time tax calculations, fraud detection systems, and cloud infrastructure on AWS.

For engineering freshers, Intuit India offers competitive packages ranging from ₹18 LPA to ₹35 LPA, with variations based on role, team, and candidate performance. Intuit's campus recruiting program targets IITs, NITs, BITS Pilani, and other premier institutions. The company is known for its exceptional employee experience, strong L&D culture, and a genuine commitment to diversity and inclusion. Intuit's annual "Intuit Day" hackathons and 10% unstructured time (similar to Google's 20% time) encourage innovation at every level.

---

Eligibility Criteria

Parameter	Requirement
Degree	B.E. / B.Tech / M.E. / M.Tech / MCA
Branches	CSE, IT, ECE, EEE, Mathematics & Computing
Minimum CGPA	7.0 / 10 (or 70% aggregate)
Backlogs	No active backlogs at time of interview
Graduation Year	2025 / 2026 pass-out batch
Gap Year Policy	Maximum 1 year with valid documented reason
Skills Preferred	Java, Python, AWS basics, strong algorithms

---

Intuit Campus Recruitment – Selection Process

Intuit's hiring process is built to assess both technical excellence and alignment with its "Customer Obsession" philosophy:

1. Online Application / Campus Shortlisting — Resume screening based on CGPA, relevant coursework, internships, and project quality. Candidates shortlisted from college placement cells or Intuit's Careers portal.

2. Online Assessment (Aptitude + Coding) — A 90–120 minute proctored test on HackerRank or Codility. Sections include quantitative aptitude, logical reasoning, verbal ability, and 2–3 coding problems.

3. Technical Interview Round 1 (DSA) — 45–60 minutes of live coding focused on data structures (arrays, trees, graphs, heaps), algorithms, and problem analysis. Interviewers expect candidates to talk through their approach.

4. Technical Interview Round 2 (Low-Level Design / Domain) — Object-oriented design and low-level system design: design a QuickBooks transaction module, a TurboTax form validator, or a notification service. Tests OOP mastery and real-world thinking.

5. Technical Interview Round 3 (High-Level System Design) — For senior-leaning fresher roles: design scalable systems like a tax filing platform, a credit score service, or a multi-tenant SaaS billing system.

6. Culture Fit / Behavioral Round — Intuit values "Customer Obsession," "Innovation," "Integrity," and "Courage." Interviewers probe for alignment using STAR-format questions.

7. HR Interview — Compensation expectation alignment, role and team preferences, joining date, relocation discussion.

8. Offer Rollout & Background Check — Offers are typically issued within 2–3 weeks post-final interview.

---

Intuit Online Assessment – Exam Pattern

Section	Topics Covered	No. of Questions	Duration
Quantitative Aptitude	Percentages, Tax Calculations, Interest, Ratios, Probability	15	20 min
Logical Reasoning	Blood Relations, Syllogisms, Puzzles, Sequences	10	15 min
Verbal Ability	RC Passages, Error Identification, Vocabulary in Context	10	15 min
Coding Problems	DSA + OOP (Easy to Medium, 1 Medium-Hard)	2–3	45–60 min
Total		~38	~110 min

Note: Intuit's aptitude questions often have a financial flavor — tax calculations, compound interest, accounting ratios. This reflects the company's domain. No negative marking. Coding is judged on correctness, complexity, and code cleanliness.

---

Practice Questions with Detailed Solutions

Section A: Aptitude Questions (Financial Focus)

---

Q1. Ravi earns ₹8,00,000 per year. He falls in the 30% tax slab for income above ₹6,00,000 and 20% for ₹3,00,001–₹6,00,000. No tax up to ₹3,00,000. What is his total tax liability? (Simplified old regime)

Solution:

• 0–₹3,00,000: No tax = ₹0
• ₹3,00,001–₹6,00,000 = ₹3,00,000 at 20% = ₹60,000
• ₹6,00,001–₹8,00,000 = ₹2,00,000 at 30% = ₹60,000
• Total tax = ₹1,20,000 ✓

This is a real-world TurboTax-style calculation question!

---

Q2. A business takes a loan of ₹5,00,000 at 12% per annum compound interest for 2 years. What is the total amount repayable?

Solution: A = P(1 + r/100)^t = 5,00,000 × (1.12)² = 5,00,000 × 1.2544 = ₹6,27,200 ✓

---

Q3. Intuit's QuickBooks processes 2,000 invoices per hour for a business. If 5% are returned/disputed, how many valid invoices are processed in a 9-hour workday?

Solution: Total invoices in 9 hours = 2,000 × 9 = 18,000 Valid invoices = 18,000 × (1 - 0.05) = 18,000 × 0.95 = 17,100 invoices ✓

---

Q4. A small business's profit in Q1 is ₹1,20,000. It decreases by 15% in Q2 and then increases by 25% in Q3. What is the profit in Q3?

Solution: Q2 profit = 1,20,000 × 0.85 = 1,02,000 Q3 profit = 1,02,000 × 1.25 = ₹1,27,500 ✓

---

Q5. The debt-to-equity ratio of a company is 3:5 and total capital is ₹40 lakhs. What is the equity amount?

Solution: Total ratio parts = 3 + 5 = 8 Equity = (5/8) × 40 = ₹25 lakhs ✓ Debt = (3/8) × 40 = ₹15 lakhs

---

Q6. Credit Karma shows a customer's credit utilization ratio as 35%. If their total credit limit is ₹2,00,000, how much credit have they used?

Solution: Credit used = 2,00,000 × 0.35 = ₹70,000 ✓

Optimal credit utilization for a good score is below 30% (financial literacy tip relevant to Intuit's domain).

---

Q7. A SaaS company has Monthly Recurring Revenue (MRR) of ₹50,00,000. Annual churn rate is 12%. What is the net MRR after 12 months accounting for churn (assuming no new customers)?

Solution: Monthly churn rate ≈ 12%/12 = 1% per month After 12 months: MRR × (1 - 0.01)^12 = 50,00,000 × (0.99)^12 = 50,00,000 × 0.8864 = ₹44,32,000 ✓

---

Section B: Logical Reasoning

---

Q8. All tax returns are financial documents. Some financial documents are confidential. Can we conclude: Some tax returns are confidential?

Solution: This is a syllogism. Premise 1: All tax returns → financial documents. Premise 2: Some financial documents → confidential. The intersection of "tax returns" within "financial documents" might or might not overlap with "confidential financial documents." Conclusion: Cannot be definitively concluded. (The answer is "possibility exists" but not certain) ✓

---

Q9. In a financial reporting team, A ranks 4th from top and 7th from bottom. How many members are in the team?

Solution: Total = (Rank from top) + (Rank from bottom) - 1 = 4 + 7 - 1 = 10 members ✓

---

Section C: Coding Problems

---

Q10. Given a list of transactions, calculate the running balance. Flag any transaction that would cause a negative balance (overdraft protection — core QuickBooks feature).

def processTransactions(transactions: list, initial_balance: float) -> dict:
    """
    transactions: list of (transaction_id, amount) 
                  positive = credit, negative = debit
    Returns: running balances and list of overdraft transaction_ids
    """
    balance = initial_balance
    running_balances = {}
    overdrafts = []
    
    for txn_id, amount in transactions:
        if balance + amount < 0:
            overdrafts.append(txn_id)
            # In QuickBooks: declined or flagged, balance unchanged
            running_balances[txn_id] = balance  # No change
        else:
            balance += amount
            running_balances[txn_id] = balance
    
    return {
        "final_balance": balance,
        "running_balances": running_balances,
        "overdrafts": overdrafts
    }

# Example:
# transactions = [("T1", 1000), ("T2", -500), ("T3", -700), ("T4", 300)]
# initial_balance = 100
# T1: 100+1000 = 1100 ✓
# T2: 1100-500 = 600 ✓
# T3: 600-700 = -100 → OVERDRAFT, flagged, balance stays 600
# T4: 600+300 = 900 ✓
# Time: O(n), Space: O(n)

---

Q11. Find all unique pairs in an array that sum to a given tax bracket threshold.

def findPairsWithSum(arr: list, target: int) -> list:
    seen = set()
    pairs = set()
    
    for num in arr:
        complement = target - num
        if complement in seen:
            pairs.add((min(num, complement), max(num, complement)))
        seen.add(num)
    
    return list(pairs)

# Example: arr=[1,5,3,7,4,2,6], target=8
# Pairs: (1,7), (2,6), (3,5)
# Time: O(n), Space: O(n)

# Extension: Count pairs (without storing them)
def countPairs(arr, target):
    count_map = {}
    pairs = 0
    for num in arr:
        complement = target - num
        if complement in count_map:
            pairs += count_map[complement]
        count_map[num] = count_map.get(num, 0) + 1
    return pairs

---

Q12. Implement a simple expression evaluator for tax formula strings (e.g., "income * 0.30 - deductions").

def evaluate(expression: str) -> float:
    """
    Evaluates simple arithmetic expressions.
    Supports: +, -, *, /, parentheses, integers/floats
    """
    def helper(tokens, idx):
        stack = []
        num = 0
        sign = 1
        
        while idx < len(tokens):
            tok = tokens[idx]
            if tok.lstrip('-').replace('.','').isdigit():
                num = float(tok)
                stack.append(sign * num)
                num = 0
                sign = 1
            elif tok == '+':
                sign = 1
            elif tok == '-':
                sign = -1
            elif tok == '*':
                idx += 1
                right = float(tokens[idx])
                stack[-1] *= right
            elif tok == '/':
                idx += 1
                right = float(tokens[idx])
                stack[-1] /= right
            elif tok == '(':
                val, idx = helper(tokens, idx + 1)
                stack.append(sign * val)
            elif tok == ')':
                return sum(stack), idx
            idx += 1
        
        return sum(stack), idx
    
    # Tokenize
    import re
    tokens = re.findall(r'\d+\.?\d*|[+\-*/()]', expression)
    result, _ = helper(tokens, 0)
    return result

# For production use Python's ast.literal_eval or a proper parser
# eval() is unsafe for user inputs in financial systems!
# Example: evaluate("100 * 0.30") → 30.0

---

Q13. Group anagrams together — used in Intuit's document deduplication systems.

from collections import defaultdict

def groupAnagrams(strs: list) -> list:
    anagram_map = defaultdict(list)
    
    for s in strs:
        # Sort characters to create canonical form
        key = tuple(sorted(s))
        anagram_map[key].append(s)
    
    return list(anagram_map.values())

# Example:
# Input: ["eat","tea","tan","ate","nat","bat"]
# Output: [["eat","tea","ate"],["tan","nat"],["bat"]]

# Alternative key using character count (faster for long strings):
def groupAnagramsCount(strs):
    anagram_map = defaultdict(list)
    for s in strs:
        count = [0] * 26
        for c in s:
            count[ord(c) - ord('a')] += 1
        anagram_map[tuple(count)].append(s)
    return list(anagram_map.values())

# Time: O(n * k) where k = avg string length, Space: O(n*k)

---

Q14. Validate a Credit Karma-style credit score entry — string validation with business rules.

def validateCreditEntry(entry: dict) -> tuple:
    """
    Validates a credit score entry with financial business rules.
    Returns (is_valid: bool, errors: list)
    """
    errors = []
    
    # Rule 1: Score must be 300-850 (FICO range)
    score = entry.get('credit_score')
    if not isinstance(score, int) or not (300 <= score <= 850):
        errors.append(f"Credit score {score} is out of valid range (300-850)")
    
    # Rule 2: Utilization must be 0-100%
    utilization = entry.get('credit_utilization', -1)
    if not (0 <= utilization <= 100):
        errors.append(f"Credit utilization {utilization}% is invalid")
    
    # Rule 3: Payment history must be a valid category
    valid_histories = {'Excellent', 'Good', 'Fair', 'Poor'}
    history = entry.get('payment_history', '')
    if history not in valid_histories:
        errors.append(f"Payment history '{history}' must be one of {valid_histories}")
    
    # Rule 4: Account age must be positive
    age = entry.get('account_age_months', -1)
    if age < 0:
        errors.append("Account age cannot be negative")
    
    # Rule 5: Business rule — high utilization with poor payment history is flagged
    if utilization > 80 and history == 'Poor':
        errors.append("WARNING: High-risk profile — consider credit counseling")
    
    return (len(errors) == 0, errors)

# This demonstrates domain-specific validation that Intuit values

---

Q15. Implement merge sort and explain why it's preferred for external sorting of large financial records.

def mergeSort(arr: list) -> list:
    if len(arr) <= 1:
        return arr
    
    mid = len(arr) // 2
    left = mergeSort(arr[:mid])
    right = mergeSort(arr[mid:])
    
    return merge(left, right)

def merge(left: list, right: list) -> list:
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i]); i += 1
        else:
            result.append(right[j]); j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

# Time: O(n log n) — guaranteed, even worst case
# Space: O(n) auxiliary

# Why preferred for financial records (External Sort):
# QuickBooks/TurboTax may have millions of transactions that don't fit in RAM.
# Merge sort is the basis for external sorting because:
# 1. It's naturally sequential — reads data in order (good for disk I/O)
# 2. Two sorted files can be merged with O(1) extra memory (streaming merge)
# 3. Chunk-sort-merge: load 1GB chunks, sort in memory, write to disk,
#    then k-way merge the sorted chunks using a min-heap
# QuickSort is NOT suitable for external sort due to random access patterns.

---

HR Interview Questions & Sample Answers

HR Q1: Why Intuit? Why financial software specifically?

Sample Answer: "Financial stress affects millions of people daily, and most of it comes from complexity — tax codes that are impossible to understand, accounting that small business owners have no time to learn. Intuit sits right at the intersection of technology and financial empowerment. What drew me specifically is TurboTax and QuickBooks' ability to take something that requires an expert and make it accessible to anyone. I want to build technology that removes barriers, and Intuit's mission of 'powering prosperity' is exactly that. The Bangalore center's full ownership of product areas — not just maintaining legacy code — means I'd be building things that matter from day one."

---

HR Q2: Tell me about a time you demonstrated "Customer Obsession."

Sample Answer: "During a college project building a personal expense tracker app, I initially designed the interface the way I thought made sense — chronological entries with category filters. After getting 10 of my classmates to use it for a week, I found they all struggled to find their highest expenses. None of them asked for it, but when I added a 'Top Spenders' dashboard, they loved it. I learned that customer obsession means proactively solving problems users haven't articulated yet. You have to watch them use your product and understand what they're actually trying to achieve, not just what they say they want."

---

HR Q3: How do you handle working with legacy code bases (common at Intuit, which has products from 1983)?

Sample Answer: "I actually find legacy code fascinating — it's archaeology. Every weird design choice has a story behind it: a constraint that no longer exists, a bug that was fixed with a workaround that became permanent. My approach is: understand before touching. I read the code, look at git history, talk to people who wrote it. Then I make the smallest possible change that fixes the problem, write tests around it, and leave the code slightly better than I found it. The Boy Scout Rule — always leave the campground cleaner than you found it — applies perfectly to legacy codebases."

---

HR Q4: Describe a time you had to learn something new quickly under pressure.

Sample Answer: "Two weeks before our final project demo, we decided to migrate from REST to GraphQL to give our frontend more flexibility. I had never used GraphQL before. I spent the first weekend going through the official docs and building a toy project. By day 4 I had our schema designed, and by day 10 the migration was complete with fewer bugs than our REST implementation. The pressure actually helped me focus. I've learned that I can pick up new frameworks fast if I anchor on fundamentals — in this case, understanding the query language theory made the implementation straightforward."

---

HR Q5: What would you do if you noticed a colleague taking a shortcut that compromised data security?

Sample Answer: "I'd address it directly and privately first — not escalate immediately. I'd say something like, 'Hey, I noticed X approach here — I'm concerned it might expose customer financial data because Y. Can we find a few minutes to talk through it?' Most people take shortcuts not because they don't care about security but because they didn't see the risk. If the conversation didn't resolve it, and the risk was real, I'd escalate to our team lead or security team. In fintech, customer data protection is non-negotiable. The cost of a breach — both to users and the company's trust — is always higher than the cost of doing it right."

---

Preparation Tips for Intuit Placement 2026

• Learn Financial Concepts: Understand basic accounting (P&L, balance sheet, cash flow), tax slabs, GST, payroll calculations, and SaaS metrics (MRR, ARR, churn). This domain knowledge distinguishes Intuit candidates.
• Focus on Java and Python: Intuit's backend is heavily Java-based. Know Java generics, collections, concurrency (ExecutorService, CompletableFuture), and Spring Boot basics if possible.
• Practice OOP Design: Intuit Technical Round 2 focuses on low-level design. Practice designing systems like a tax form processor, invoice manager, or notification service using OOP principles.
• Master SQL and Database Design: Know normalization, JOINs, indexes, transactions (ACID), and query optimization. Financial data is relational by nature.
• Study AWS Basics: Intuit runs on AWS. Understand S3, EC2, Lambda, RDS, SQS, and SNS at a conceptual level. AWS Certified Developer Associate preparation helps.
• Prepare Financial Aptitude Questions: Expect tax calculations, compound interest, financial ratios, and SaaS metric questions in the aptitude section. Practice with CA Foundation books or finance websites.
• Know Clean Code Principles: Read "Clean Code" by Robert Martin. Intuit values code that is readable, maintainable, and well-tested over clever or complex code.

---

Frequently Asked Questions (FAQ)

Q1: What is the Intuit fresher salary package in India for 2026? Intuit freshers in India can expect ₹18–35 LPA depending on role (SDE-1 vs. Data Engineer vs. ML Engineer), team, and college. Total comp includes base salary, annual bonus, RSUs (4-year vesting), and benefits. IIT candidates consistently land at the higher end.

Q2: What programming languages should I prepare for Intuit's coding test? Java is the primary language at Intuit. Python and JavaScript are also accepted in tests. Knowing Java well — especially Collections, Streams, and basic concurrency — gives you an advantage in technical interviews.

Q3: Does Intuit's interview cover financial domain knowledge? Yes, especially in the aptitude section (financial math) and behavioral round (customer obsession in a financial context). You don't need to be a CA, but understanding how tax, invoicing, and accounting work helps significantly.

Q4: What is Intuit's "Catalyst" program for freshers? Catalyst is Intuit's structured onboarding for new graduates that includes technical training, mentorship, rotational projects, and leadership development. It's one of the best new-grad programs in the industry and typically lasts 6–12 months.

Q5: How many interview rounds does Intuit typically have? Typically 2–3 technical rounds (DSA + LLD + optionally HLD), 1 culture/behavioral round, and 1 HR round. The full process takes 3–6 weeks from assessment to offer.

---

Last Updated: March 2026 | Source: Student testimonials, Glassdoor, Intuit Careers Portal, Levels.fyi