Technical Interview Preparation Guide 2025

Round 1: Recruiter Screen (30 min)
- Background check
- Basic technical questions
- Salary expectations
- Availability

Round 2: Online Assessment (60-90 min)
- Coding challenges (HackerRank, CodeSignal)
- Multiple technical questions
- Timed environment

Round 3: Technical Screen (45-60 min)
- 1-2 coding questions
- Live coding (Google Doc, CodeSandbox)
- System design (for mid-senior roles)

Round 4: Onsite (4-6 hours)
- 3-5 coding interviews
- 1 system design interview
- 1 behavioral interview
- Lunch with team

Round 5: Hiring Manager (30 min)
- Culture fit
- Team dynamics
- Offer discussion

Emerging trends:
✓ AI-assisted coding evaluation
✓ Take-home projects replacing some coding rounds
✓ System design for junior roles
✓ Practical problem-solving over algorithms
✓ Collaboration and communication emphasis
✓ Open-source contribution evaluation
✓ Pair programming interviews

// 1. Arrays and Strings
Operations: O(1) access, O(n) search
Common patterns:
- Two pointers
- Sliding window
- Prefix sums
- Hash map optimization

Example: Two Sum
function twoSum(nums, target) {
  const map = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement), i];
    }
    map.set(nums[i], i);
  }
  return [];
}
// Time: O(n), Space: O(n)

// 2. Linked Lists
Operations: O(1) insertion/deletion
Common patterns:
- Fast and slow pointers
- Dummy node technique
- Reversal

Example: Reverse Linked List
function reverseList(head) {
  let prev = null;
  let current = head;
  while (current) {
    const next = current.next;
    current.next = prev;
    prev = current;
    current = next;
  }
  return prev;
}
// Time: O(n), Space: O(1)

// 3. Trees and Graphs
Operations: O(n) traversal
Common patterns:
- DFS (recursive/iterative)
- BFS (level-order)
- Tree properties (height, depth, balance)

Example: Maximum Depth of Binary Tree
function maxDepth(root) {
  if (!root) return 0;
  return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
// Time: O(n), Space: O(h) where h is height

// 4. Hash Tables
Operations: O(1) average, O(n) worst
Common patterns:
- Frequency counting
- Grouping
- Caching

// 5. Heaps and Priority Queues
Operations: O(log n) insertion/deletion
Common patterns:
- K-way merge
- Top K elements
- Streaming data

Example: Top K Frequent Elements
function topKFrequent(nums, k) {
  const count = {};
  for (const num of nums) {
    count[num] = (count[num] || 0) + 1;
  }

  const heap = new MaxHeap();
  for (const [num, freq] of Object.entries(count)) {
    heap.insert({ num, freq });
  }

  const result = [];
  for (let i = 0; i < k; i++) {
    result.push(heap.extract().num);
  }
  return result;
}

1. Sliding Window
function maxSubarray(nums, k) {
  let max = 0;
  let windowSum = 0;

  for (let i = 0; i < nums.length; i++) {
    windowSum += nums[i];
    if (i >= k - 1) {
      max = Math.max(max, windowSum);
      windowSum -= nums[i - k + 1];
    }
  }
  return max;
}

2. Two Pointers
function isPalindrome(s) {
  let left = 0;
  let right = s.length - 1;

  while (left < right) {
    if (s[left] !== s[right]) return false;
    left++;
    right--;
  }
  return true;
}

3. Fast and Slow Pointers
function hasCycle(head) {
  let slow = head;
  let fast = head;

  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) return true;
  }
  return false;
}

4. Merge Intervals
function merge(intervals) {
  intervals.sort((a, b) => a[0] - b[0]);
  const merged = [intervals[0]];

  for (let i = 1; i < intervals.length; i++) {
    const current = intervals[i];
    const last = merged[merged.length - 1];

    if (current[0] <= last[1]) {
      last[1] = Math.max(last[1], current[1]);
    } else {
      merged.push(current);
    }
  }
  return merged;
}

5. Cyclic Sort
function findMissing(nums) {
  let i = 0;
  while (i < nums.length) {
    const j = nums[i];
    if (nums[i] < nums.length && nums[i] !== nums[j]) {
      [nums[i], nums[j]] = [nums[j], nums[i]];
    } else {
      i++;
    }
  }

  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== i) return i;
  }
  return nums.length;
}

6. In-place Reversal of Linked List
7. Tree Breadth-First Search
8. Depth-First Search
9. Two Heaps
10. Subsets
11. Modified Binary Search
12. Top K Elements
13. K-way Merge
14. 0/1 Knapsack
15. Topological Sort

Step 1: Understand the Problem (5 minutes)
- Ask clarifying questions
- Identify inputs and outputs
- Discuss edge cases
- Confirm understanding

Example questions:
- "Can the array be empty?"
- "Are there duplicates?"
- "What's the expected input size?"
- "Should I handle invalid input?"

Step 2: Think Out Loud (5 minutes)
- Discuss potential approaches
- Analyze time/space complexity
- Consider trade-offs
- Choose optimal approach

Step 3: Write Code (15-20 minutes)
- Start with brute force if needed
- Optimize step by step
- Use meaningful variable names
- Add comments for clarity

Step 4: Test Your Code (5 minutes)
- Walk through examples
- Test edge cases
- Fix bugs
- Verify correctness

Step 5: Analyze Complexity (2 minutes)
- Time complexity: Big O notation
- Space complexity: Auxiliary space
- Discuss optimizations

// 12-week preparation plan

Week 1-2: Fundamentals
- Arrays and Strings
- Hash Tables
- Practice: 50 easy problems

Week 3-4: Linked Lists and Recursion
- Two Pointers
- Fast/Slow Pointers
- Practice: 50 easy/medium problems

Week 5-6: Trees and Graphs
- BFS/DFS
- Tree traversal
- Practice: 50 medium problems

Week 7-8: Advanced Data Structures
- Heaps
- Tries
- Practice: 50 medium problems

Week 9-10: Dynamic Programming
- Memoization
- Tabulation
- Practice: 50 hard problems

Week 11-12: Mock Interviews
- Practice with timer
- Peer mock interviews
- Review weak areas

Daily routine:
- 2-3 problems per day
- 1 medium, 1 easy (warmup)
- Weekend: Review and mock interviews

// Key concepts to master

1. Scalability
- Vertical scaling (scale up)
- Horizontal scaling (scale out)
- Load balancing
- Caching strategies

2. Availability
- Redundancy
- Failover
- Replication
- Health checks

3. Reliability
- Data consistency
- Error handling
- Monitoring
- Disaster recovery

4. Efficiency
- Performance optimization
- Resource utilization
- Cost optimization
- Latency reduction

Step 1: Clarify Requirements (5 minutes)
Ask questions:
- Functional requirements
- Non-functional requirements
- Constraints and assumptions
- Scale estimates

Example URL Shortener:
Functional:
- Create short URL
- Redirect to original URL
- Custom aliases
- Expiration dates

Non-functional:
- High availability
- Low latency
- Scalable to 100M users

Scale:
- 100M URLs stored
- 10M redirects/day
- 1000 requests/second at peak

Step 2: Back-of-the-Envelope Estimation (5 minutes)
Calculate:
- Storage requirements
- Bandwidth needs
- QPS (queries per second)
- Database size

URL Shortener calculations:
- URL: 100 chars × 1 byte = 100 bytes
- Hash: 7 bytes
- Metadata: 50 bytes
- Total per URL: ~200 bytes
- 100M URLs: 200 bytes × 100M = 20GB
- Daily redirects: 10M × 200 bytes = 2GB/day

Step 3: Data Model (5 minutes)
Design schema:
URLs table:
- id: INT PRIMARY KEY
- short_code: VARCHAR(7) UNIQUE
- long_url: TEXT
- created_at: TIMESTAMP
- expires_at: TIMESTAMP
- user_id: INT
- click_count: INT

Users table:
- id: INT PRIMARY KEY
- email: VARCHAR(255) UNIQUE
- created_at: TIMESTAMP

Step 4: High-Level Design (10 minutes)
Architecture components:
- Load Balancer
- API Server
- Database (PostgreSQL)
- Cache (Redis)
- CDN (Cloudflare)

Step 5: Detailed Design (15 minutes)
Deep dive into:
- URL generation: Base62 encoding
- Caching strategy: LRU cache
- Database sharding: Hash-based
- Read replicas: For scaling reads

Step 6: Bottlenecks and Solutions (5 minutes)
Identify and solve:
- Single point of failure
- Database bottleneck
- Cache stampede
- Hot partitioning

Step 7: Trade-offs and Improvements (5 minutes)
Discuss:
- Strong vs. eventual consistency
- SQL vs. NoSQL
- Synchronous vs. asynchronous
- Cost vs. performance

Must-prepare topics:
1. URL Shortener (bit.ly)
2. Design Instagram
3. Design Twitter/X
4. Design Chat System (WhatsApp)
5. Design File Storage (Dropbox)
6. Design Netflix
7. Design Uber
8. Design Unique ID Generator
9. Design Web Crawler
10. Design Key-Value Store

// Load Balancers
Types:
- L4 (Transport layer)
- L7 (Application layer)
- Hardware vs. Software

Algorithms:
- Round robin
- Least connections
- IP hash
- Least response time

// Caching
Strategies:
- Cache-aside
- Write-through
- Write-back
- Write-around

Tools:
- Redis (in-memory)
- Memcached (simple)
- CDN (geographic)

// Databases
SQL:
- PostgreSQL (reliable)
- MySQL (popular)
- SQL Server (enterprise)

NoSQL:
- MongoDB (document)
- Cassandra (wide column)
- Redis (key-value)
- Elasticsearch (search)

// Message Queues
Options:
- Kafka (high throughput)
- RabbitMQ (reliable)
- AWS SQS (managed)
- Redis Pub/Sub (simple)

Use cases:
- Async processing
- Event-driven architecture
- Microservices communication

Structure your answers:

Situation: Set the scene
"Last quarter, our team was tasked with..."

Task: Describe your responsibility
"I was responsible for implementing the new feature..."

Action: Explain what you did
"I first analyzed the existing codebase, then designed
a solution using React hooks, and implemented it with
comprehensive tests..."

Result: Share the outcome
"The feature launched on time, and user engagement
increased by 30%. My manager specifically thanked
me for the clean architecture..."

Leadership:
- "Tell me about a time you led a team"
- "How do you handle conflict?"
- "Describe a mentoring experience"

Teamwork:
- "How do you collaborate with designers?"
- "Tell me about a difficult team member"
- "How do you give feedback?"

Challenges:
- "Describe a project that failed"
- "How do you handle pressure?"
- "Tell me about a time you messed up"

Growth:
- "What's your greatest weakness?"
- "How do you stay current?"
- "What do you want to learn?"

Good questions show interest and intelligence:

About the role:
- "What does success look like in this position?"
- "What's the biggest challenge your team faces?"
- "How does this role interact with other teams?"

About the company:
- "What's the engineering culture like?"
- "How do you make technical decisions?"
- "What's your approach to innovation?"

About growth:
- "What opportunities for learning exist?"
- "How do you support career growth?"
- "What's the typical career path?"

About the team:
- "How is the team structured?"
- "What's your tech stack and why?"
- "What's the biggest technical challenge?"

// Weekly mock interview schedule

Week 1-4: Peer Practice
- Find interview partner
- Practice 2x per week
- Alternate interviewer/interviewee
- Record and review sessions

Week 5-8: Professional Mocks
- Interviewing.io (anonymous)
- Pramp (peer matching)
- Career coaching (paid)
- Alumni network

Week 9-12: Final Prep
- Daily mock interviews
- Time yourself strictly
- Practice with whiteboard
- Record video for review

// Light preparation only
✓ Review key algorithms
✓ Practice 2-3 easy problems
✓ Prepare questions for interviewer
✓ Get good sleep (8+ hours)
✓ Prepare outfit and equipment

✗ Don't:
✗ Cram new topics
✗ Stay up late studying
✗ Stress about outcomes
✗ Compare with others

Technical checklist:
✓ Stable internet (Ethernet preferred)
✓ Backup hotspot (phone)
✓ Noise-canceling headphones
✓ Professional background
✓ Good lighting (face visible)
✓ Fully charged laptop
✓ Backup device ready
✓ Test all software beforehand
✓ Have water nearby
✓ Notebook and pen

Environment:
- Quiet room
- Clean background
- Professional attire
- Minimize distractions
- Inform family/roommates

Communication strategies:
1. Think out loud constantly
2. Ask clarifying questions
3. Confirm understanding before coding
4. Explain your thought process
5. Test your code thoroughly
6. Handle mistakes gracefully

If you get stuck:
- Take a deep breath
- Step back and restate problem
- Try a simpler approach
- Ask for a hint (don't give up)
- Show problem-solving process

Time management:
- Watch the clock
- Don't spend too long on one approach
- It's okay to not finish optimally
- Communication > perfect solution

Within 24 hours:
Send thank-you notes:

Hi [Interviewer Name],

Thank you for taking the time to interview me today.
I really enjoyed our discussion about [specific topic].
Your insights about [specific detail] were valuable.

I'm excited about the opportunity to join [Company]
and contribute to [specific project/team].

Best regards,
[Your Name]

Customize each note:
- Reference specific discussion
- Reiterate interest
- Keep it brief
- Send within 24 hours

// When you get an offer!

Don't accept immediately:
- Express gratitude
- Ask for time to decide
- Review full package
- Compare with other offers

Total compensation:
- Base salary
- Bonus (signing, performance)
- Equity (RSUs, options)
- Benefits (health, 401k)
- Perks (remote, PTO)
- Growth opportunities

Negotiation script:
"Thank you for the offer. I'm very excited about
joining the team. Based on my research and
comparing with similar positions, I was hoping
for a base salary of $X. Is there flexibility?"

Rules:
✓ Be polite and professional
✓ Justify with market data
✓ Consider total package
✓ Get everything in writing
✓ Know your walk-away point

// Interview preparation spreadsheet

Date | Company | Role | Round | Result | Notes
3/1  | Google  | SWE  | Phone | Pass  | Good DS questions
3/15 | Google  | SWE  | Onsite | Fail  | Weak system design
4/1  | Meta    | SWE  | Phone | Pass  | Improved!

Analyze patterns:
- Which topics need work?
- Which companies align best?
- What's your conversion rate?
- Are you improving over time?

// Job search is a marathon

Maintain balance:
- Set daily/weekly goals
- Celebrate small wins
- Take regular breaks
- Exercise and sleep
- Talk to supportive friends

Remember:
- Rejection is normal
- It's a numbers game
- Each interview is practice
- The right fit will come
- Your worth isn't defined by offers