Land Your Dream Job : Acing Product Based Company Interviews

I will be delivering a webinar on the above topic. Secure your seat today

https://topmate.io/grusiya/870968

Don't settle for anything less than your dream job. Get ready to dominate your product-based company interviews !!!

Read me first 💥

Join our #Amazon Exports & Expansion (AEE) Tech team in #Chennai as a System Development Engineer (SysDE - L4).

We are seeking professionals with expertise in distributed systems, OS, storage, and networks. If you're experienced in languages like C++, Java, or Python, have operational excellence experience (#ApplicationEngineer OR #SystemEngineer OR #SDE), and love solving complex challenges, this opportunity is for you.

As a Sys Development Engineer at Amazon, you'll build resilient systems and enhance product development, ensuring robustness and supporting Software Development Engineers. Don't miss this chance to be part of the exciting journey of the AEE team in #Chennai. Reach out to me shnricha@amazon.com.

Job Link : https://lnkd.in/gNzDNW-q
Exp - 1.5-4.5 years, Location - Chennai

Blind article : I'm following up from my previous post and sharing some data points on my sys design approach.
https://www.teamblind.com/post/How-I-got-into-FAANG-FpwTWHuo

It is not an exhaustive list and might not work for everyone. Also it is not a one size fits all thing but I hope it helps you to draft a plan and figure out how to tackle the sys design.

Resources:
1. https://github.com/donnemartin/system-design-primer
2. https://github.com/binhnguyennus/awesome-scalability
3. Youtube InfoQ channel - https://www.youtube.com/user/MarakanaTechTV
4. Youtube SDE Skills channel - https://www.youtube.com/channel/UCPumyEKs86w-GtWDd2XQYtg
5. Amazon DynamoDB - https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf
6. Grokking the sys design interview - https://www.educative.io/courses/grokking-the-system-design-interview

Process:
- I started with reading Amazon DynamoDB paper. This is a very practical paper to understand consistent hashing.
- I also started spending time on Donne Martin Sys Design (resource 1) and tried to go through each section. I went through this page 2-3 times entirely to develop some understanding (my philosophy is to read one book 10 times than reading ten books 1 time). I was not just reading it page but making my notes summarizing each building block, its usage, common systems where it is used and its drawbacks.
- For each component (whether it is a caching, messageQ, DBs) I searched for Youtube videos and gathered more info on it. I penned it down in my notes, copied any diagram I found its usage in, stored links to videos or blogs I saw mentioned something useful about it.
- I started reading cloud design pattern - https://docs.microsoft.com/en-us/azure/architecture/patterns/ - It has some good info on what the nomenclature is and how some components are typically used.
- I started going over practical system designs - Read mostly from Uber blog, Facebook blog and Yelp architecture.
- I read about few system design practical questions and analyzed what sort of things I need to address there - Grokking the sys design and Donne Martin has some good examples on these.
- Before each interview I only referred to my notes on various components/building blocks instead of researching again.
- Finally I made sure I practiced on whiteboard with solving 2-3 sys design problems. Idea was to complete them in 45 mins (more on this below).

My 9 Step approach
------------------------
1. Gather requirements(use case, who is customer, why is this needed etc.)
2. Discuss system constraints (any limitations, what is allowed vs what is not)
3. Do capacity estimation, specifically
- traffic estimation (read request per sec, write requests per sec)
- storage estimation (storage needed to store worth 3 yrs of stored 'object')
- bandwidth estimate (#of bytes/sec system should handle for incoming and outgoing traffic)
- cache estimate (memory needed to cache some of the hot read responses, 80-20 rule)

4. Define System APIs - Rest style mostly (read about Rest vs Soap)
5. Draw top level system diagram (client, web servers, platform, database, worker services)
6. Discuss database design choice (schema, SQL or no-SQL)
7. Perfect your design for a single user -> get a Minimum Viable Product
8. Discuss scaling
- find bottlenecks and single point of failures (put load balancer, caching, replication, Message queues, Asynchronous workers)
9. Test and Review your design (Treat this one as same what you do in coding interview)
- walk through your system and see if we met each customers need
- did we provide APIs for each customer ask
- did we walk over failover scenarios (not just vanilla passing case)
- did we draw system boundaries/or blocks to explain different parts of systems

If you manage to get all these steps in 45 mins you've probably addressed most of the interviewer concerns :)

Some practical examples (see if above 9 steps are followed here):
Design Tiny URL: http://tinyurl.com/jlg8zpc

🎤 Referral Call Out for SDE @ *InMobi*

Please fill this form: https://forms.gle/bdcy4GYYQPCjj4h59

*Role:* SDE-1
*Experience Required:* 1-2 years

*Timeline to Apply: 10 AM IST tomorrow!*

All the best!! 👍

Move fast!🚀

Happy Diwali 🪔
Stay happy and Never ever forget your roots 😊

Here are the 10 best tips on how you should approach to solve a problem during an interview :

1. Use a Heap for K Elements  
   - Rule: When dealing with top/maximum/minimum/closest K elements among N elements, use a Heap.  
   - Example Scenario: Finding the top 3 largest numbers in an array.

2. Binary Search or Two Pointers for Sorted Inputs  
   - Rule: If the input is a sorted array or list, use Binary Search or the Two Pointers strategy.  
   - Example Scenario: Finding a pair of numbers that sum up to a target in a sorted array.

3. Backtracking or BFS for Combinations  
   - Rule: For trying all combinations or permutations of the input, use Backtracking or Breadth-First Search (BFS).  
   - Example Scenario: Generating all subsets of a given set.

4. BFS or DFS for Trees and Graphs  
   - Rule: Most Tree or Graph questions can be solved using BFS or DFS.  
   - Example Scenario: Finding the shortest path in a graph.

5. Convert Recursion to Iteration with a Stack  
   - Rule: Every recursive solution can be rewritten as an iterative one using a Stack.  
   - Example Scenario: Converting recursive tree traversal to iterative using a stack.

6. Optimize Array Problems with HashMap or Sorting  
   - Rule: If the array solution takes O(n²) time, try using HashMap/Set for O(n) time or sorting for O(n log n) time.  
   - Example Scenario: Finding duplicates in an array.

7. Use Dynamic Programming for Optimization Problems  
   - Rule: If the problem involves maximization or minimization, use Dynamic Programming.  
   - Example Scenario: Solving the knapsack problem.

8. HashMap or Trie for Common Substrings  
   - Rule: For finding common substrings among multiple strings, use a HashMap or a Trie.  
   - Example Scenario: Finding the longest common prefix among strings.

9. Trie for String Search and Manipulation  
   - Rule: When searching or manipulating a collection of strings, a Trie is the best fit.  
   - Example Scenario: Implementing autocomplete functionality.

10. Fast & Slow Pointers for Linked Lists  
   - Rule: For Linked List problems, especially when extra space isn't allowed, use the Fast & Slow Pointer approach.  
   - Example Scenario: Detecting a cycle in a linked list.

Apologies for not being active for long. From now on, I will try to be more active here.
Thanks for being valuable members !!!

📌 Whether you're actively preparing or just want to stay sharp, this set covers a mix of patterns, including:

- Sliding Window
- Binary Search
- Graphs & Trees
- Dynamic Programming
- Backtracking
and more...

Questions List:

https://leetcode.com/problem-list/2mxn884m/

[1] How to answer any behavioural interview question

https://lnkd.in/gH3N8b5q


[2] 4 step guide for behavioural interview preparation in 3 hours

https://lnkd.in/gccxG3MP


[3] How to create 10+ stories for your past projects

https://lnkd.in/g4nv_jqU


[4] How to answer a failure story?

https://lnkd.in/gtN-Dfuv


[5] 10 behavioural interview mistakes to avoid at all cost

https://lnkd.in/gpupvYVs

LLM Resources

📹 Videos:
1. LLM Introduction: https://lnkd.in/gN8sv7Q5
2. LLMs from Scratch: https://lnkd.in/gJt-SQj2
3. Agentic AI Overview (Stanford): https://lnkd.in/gk4GKdxa
4. Building and Evaluating Agents: https://lnkd.in/ghBiVjdF
5. Building Effective Agents: https://lnkd.in/g_m78sid
6. Building Agents with MCP: https://lnkd.in/gAzBzr3W
7. Building an Agent from Scratch: https://lnkd.in/g9GR9b9F
8. Philo Agents: https://lnkd.in/gnxRq9n9

📚Books:
1. AI for the Rest of Us: https://lnkd.in/gTQyc_fi
2. Understanding Deep Learning: https://lnkd.in/g4xgvu_q
3. Building an LLM from Scratch: https://lnkd.in/g2YGbnWS
4. The LLM Engineering Handbook: https://lnkd.in/gWUT2EXe
5. AI Engineering: https://lnkd.in/gpfQSMCQ

🗂️ Repos
1. GenAI Agents: https://lnkd.in/gvfAc-9H
2. Microsoft's AI Agents for Beginners: https://lnkd.in/gK8MiVfv
3. Prompt Engineering Guide: https://lnkd.in/gJjGbxQr
4. AI Agent Papers: https://lnkd.in/gfKQ82Fs

🗺️ Guides
1. Google's Agent Whitepaper: https://lnkd.in/gFvCfbSN
2. Google's Agent Companion: https://lnkd.in/gfmCrgAH
3. Building Effective Agents by Anthropic: https://lnkd.in/gRWKANS4.
4. Claude Code Best Agentic Coding practices: https://lnkd.in/gs99zyCf
5. OpenAI's Practical Guide to Building Agents: https://lnkd.in/guRfXsFK

📜 Papers
1. ReAct: https://lnkd.in/gRBH3ZRq
2. Generative Agents: https://lnkd.in/gsDCUsWm.
3. Toolformer: https://lnkd.in/gyzrege6
4. Chain-of-Thought Prompting: https://lnkd.in/gaK5CXzD.
5. Tree of Thoughts: https://lnkd.in/gRJdv_iU.
6. Reflexion: https://lnkd.in/gGFMgjUj
7. Retrieval-Augmented Generation Survey: https://lnkd.in/gGUqkkyR.

🧑‍🏫 Courses:
1. HuggingFace's Agent Course: https://lnkd.in/gmTftTXV
2. MCP with Anthropic: https://lnkd.in/geffcwdq
3. Building Vector Databases with Pinecone: https://lnkd.in/gCS4sd7Y
4. Vector Databases from Embeddings to Apps: https://lnkd.in/gm9HR6_2
5. Agent Memory: https://lnkd.in/gNFpC542
6. Building and Evaluating RAG apps: https://lnkd.in/g2qC9-mh
7. Building Browser Agents: https://lnkd.in/gsMmCifQ
8. LLMOps: https://lnkd.in/g7bHU37w
9. Evaluating AI Agents: https://lnkd.in/gHJtwF5s
10. Computer Use with Anthropic: https://lnkd.in/gMUWg7Fa
11. Multi-Agent Use: https://lnkd.in/gU9DY9kj
12. Improving LLM Accuracy: https://lnkd.in/gsE-4FvY
13. Agent Design Patterns: https://lnkd.in/gzKvx5A4
14. Multi Agent Systems: https://lnkd.in/gUayts9s

📩 Newsletters
1. Gradient Ascent: https://lnkd.in/gZbZAeQW
2. DecodingML by Paul: https://lnkd.in/gpZPgk7J
3. Deep (Learning) Focus by Cameron: https://lnkd.in/gTUNcUVE
4. NeoSage by Shivani: https://blog.neosage.io/
5. Jam with AI by Shirin and Shantanu: https://lnkd.in/gQXJzuV8
6. Data Hustle by Sai: https://lnkd.in/gZpdTTYD

Don’t fear the agents replacing everyone else.
Learn to build them and own the advantage.

https://github.com/luongnv89/claude-howto

Learning Claude Code in a Weekend

*Senior / Staff Level Interviews Plan*

Amazon L6 / Google L5 / Meta E5 / Microsoft Senior–Principal level. Interviews at this level typically require you to:

* Consistently solve Medium problems
* Have a solid approach for most Hard problems
* Perform strongly in System Design
* Excel in Behavioral/Leadership interviews

Below is a 3-month preparation plan, broken down by week.

⸻

Phase 1 (Weeks 1–4)

Goal:

Solve 2–3 problems per day, mostly Easy/Medium, and rebuild your intuition for data structures and algorithms.

Week 1 – Arrays / Strings / Hash Maps

* Two Sum
* 3Sum
* Group Anagrams
* Top K Frequent Elements
* Longest Substring Without Repeating Characters
* Product of Array Except Self
* Sliding Window Maximum

Week 2 – Linked Lists / Stacks / Queues

* Reverse Linked List
* Merge Two Sorted Lists
* LRU Cache
* Min Stack
* Valid Parentheses
* Daily Temperatures
* Trapping Rain Water

Week 3 – Binary Trees / BSTs

* Inorder Traversal
* Level Order Traversal
* Validate BST
* Lowest Common Ancestor
* Serialize/Deserialize Binary Tree
* Binary Tree Maximum Path Sum
* Kth Smallest Element in BST

Week 4 – Heaps / Sorting / Binary Search

* Merge K Sorted Lists
* Find Median from Data Stream
* Search in Rotated Sorted Array
* Kth Largest Element
* Meeting Rooms II
* Median of Two Sorted Arrays

⸻

Phase 2 (Weeks 5–8)

Goal:

Solve 2 Medium/Hard problems per day and begin serious System Design preparation.

Week 5 – Graphs (BFS / DFS / Topological Sort)

* Number of Islands
* Clone Graph
* Course Schedule I & II
* Word Ladder
* Alien Dictionary
* Graph Valid Tree
* Pacific Atlantic Water Flow

Week 6 – Dynamic Programming (Part 1)

* Climbing Stairs
* House Robber I & II
* Coin Change
* Longest Increasing Subsequence
* Word Break
* Decode Ways
* Unique Paths

Week 7 – Dynamic Programming (Part 2)

* Edit Distance
* Regular Expression Matching
* Longest Common Subsequence
* Burst Balloons
* Interleaving String
* Palindrome Partitioning II

Week 8 – Backtracking / Trie / Union-Find

* Word Search I & II
* Permutations
* Combination Sum
* Implement Trie
* Number of Connected Components
* Accounts Merge
* Design Add and Search Words

⸻

Phase 3 (Weeks 9–12)

Goal:

Practice under interview conditions: solve and explain problems within 45 minutes, focusing on each company’s most frequently asked questions.

Weeks 9–10 – Company-Specific High-Frequency Problems

Google

* Split Array Largest Sum
* Minimum Window Substring
* Longest String Chain
* Snapshot Array
* Guess the Word

Meta

* Random Pick with Weight
* Interval List Intersections
* Nested List Weight Sum
* Binary Tree Vertical Order Traversal
* Dot Product of Sparse Vectors

Microsoft

* Spiral Matrix
* Reverse Words in a String
* Max Area of Island
* Sign of Product of Array

Apple

* 3Sum Closest
* String to Integer (atoi)
* Roman to Integer
* Two Sum II

Weeks 11–12 – Mock Interviews & Gap Analysis

* Complete at least 2–3 mock interviews per week
* Recommended platforms:
* Pramp
* Interviewing.io
* Or practice with friends/colleagues
* Review all incorrect or slow solutions
* Maintain an “error notebook” of mistakes and lessons learned
* Ensure you can:
* Write the solution within 25–30 minutes
* Clearly explain your reasoning
* Analyze time and space complexity

⸻

System Design Preparation (Critical for L6)

System Design carries significant weight at the L6 level.

Spend at least 3–4 hours per week on System Design.

Essential Design Problems

* Design URL Shortener (TinyURL)
* Design Twitter / News Feed
* Design WhatsApp / Chat System
* Design Rate Limiter
* Design Distributed Cache (Redis)
* Design YouTube / Netflix (Video Streaming)
* Design Search Autocomplete
* Design Notification System
* Design Web Crawler
* Design Uber / Ride-Sharing

Recommended Resources

* System Design Interview
* Grokking the System Design Interview
* YouTube channels:
* Tech Dummies
* Gaurav Sen
* System Design Fight Club

⸻

Behavioral (BQ) Preparation

Behavioral interviews are extremely important at the L6 level, especially around:

* Influence
* Cross-functional collaboration
* Technical decision-making
* Leadership

Prepare 8–10 STAR Stories Covering:

* Technical Leadership
* Conflict Resolution
* Ambiguity
* Cross-Team Influence
* Trade-off Decisions
* Mentoring

Company Focus Areas

* Google: Googleyness & Leadership
* Meta: Impact & Execution
* Microsoft: Growth Mindset

Practice each story until you can:

* Explain it clearly in under 2 minutes
* Expand naturally based on follow-up questions

⸻

Suggested Daily Time Allocation (2–3 Hours Per Day)

🔹 Algorithms: 1.5–2 hours (2–3 problems)

🔹 System Design: 30–45 minutes (starting in Phase 2)

🔹 Behavioral: 15–20 minutes (story preparation and practice)

⸻

Overall Target

* Approximately 150–200 problems
* Covers the popular NeetCode 150 roadmap plus company-specific high-frequency questions

Good luck with your preparation, and hopefully you’ll land the offer you’re aiming for!

Disclaimer: This plan is just for reference. Please prepare your own plan & be consistent.