When solving a DSA problem, set a timer for 20–30 minutes, depending on the difficulty, and genuinely exhaust your brain trying to figure it out.

Treat it like a challenge. Ask yourself, How can I solve this? Write down every approach you can think of, explore them in depth, and keep pushing yourself.

If you’re stuck, ask ChatGPT for hints, starting from basic and gradually moving to more advanced ones. Keep digging until you understand the approach. If you’re completely unfamiliar with the concept or it’s taking too long, move to a video solution — but pause it, think ahead, and try to figure out the next step yourself.

The key is to interact with the problem as much as possible instead of passively consuming solutions. The more you engage, experiment, and challenge yourself, the easier it becomes to get absorbed in the problem and enter a state of flow.

Started DSA for placements and grinding with similar minds.

Week 0 was revising the basics and practicing a few problems from the striver's sheet, however we then shifted to pattern wise sheet and started following it.

Week 1 Updates (Done) :

1. Two Pointers

2. Fast and Slow Pointers

3. Sliding Window (Started)

Week 2 targets :

1. Sliding Window

2. Kadane Pattern

3. Prefix Sum

4. Merge Intervals

Edit - Many of you are asking for the sheet. Well,. that's my personal sheet and I fix my daily targets and update it daily. However questions are from pratyush narain dsa sheet.

I started interviewing a bit over a year ago by grinding leetcode and system design until midnight in the office.

Prep Resource

Got super close to offers at Meta and LinkedIn (was told my onsite loop were borderline and could have gone either way) but could not secure an offer.

Fast forward a couple months, and I got laid off in March. I was a bit relieved considering I was trying to job hop. I went all in on studying and interviewing.

Landed onsite loops with Nvidia, Pinterest, Broadcom, Microsoft, Google, Netflix, Anduril, Apple and a bunch of non big tech and startups.

I hit 500+ leetcode questions and gone through all of hello interview system design videos (premium) at this point.

I felt like I was acing most of the interviews, but always get passed up for someone internal or someone with more years of experience. Especially Nvidia… I aced every single interview they threw at me and was told feedback was very positive, but they ended up going with someone internal. Maybe it was because I was borderline between junior and senior with 5yoe.

It seemed like no matter how I performed in interviews, I could never secure an offer.

Finally, I was able to land an offer with a startup. They low balled me with ~150k + mystery equity. I planned to sign as it was the only offer I had.

Then Google came in. I got successfully team matched, and received a verbal offer from them. Because of the verbal offer, I decided to decline signing with the startup as the deadline was up. Google then backtracked requiring 2 more rounds. I get an insanely stupid question that required very niche topology formula to solve efficiently, and lost my offer.

At this point, I was defeated. Google GMFU and I lost my startup offer because of them. I was burnt out. I’ve gone through 50+ different companies (big tech and startups alike) with 100+ interviews at this point. Considered taking a career break and traveling for a couple of months.

I decided to do one last sprint, and mass applied. Landed onsites at DoorDash, Amazon, and LinkedIn. Before I even had time to wrap up my loops with Amazon and LinkedIn, DoorDash came back and told me they were proceeding with an offer.

It was a grind, but I finally did it. My TC went from ~190k -> 320k. Being laid off ended up being a net positive, despite the uncertainty at the time.

To any job searchers: the market is very rough, and the bar is way higher than it was 3+ years ago. I landed multiple offers back then, but struggled a lot during this job search despite being much more competent technically (both experience and interview wise). But staying consistent ended up paying off for me. Best of luck out there!

SDE interview questions

Disclosure: Sharing this story from community interview experience.

Hi folks! About a year ago, I was in your place, struggling quite a bit with DSA. I was particularly weak at identifying patterns in problems, and on top of that, I couldn’t find enough questions to practise each pattern thoroughly.

To make things easier, I built [DSASheeeet](https://dsasheeeet.vercel.app/home), where you can practise almost every possible problem-solving pattern with a carefully curated set of problems to help you understand each topic inside out.

Apart from that, it also features 423 companies, so you can prepare for upcoming company assessments without spending hours researching questions. Whether you’re preparing for placements, planning a job switch, or struggling to identify patterns in DSA problems, DSASheeeet is here to make your life easier.

Check it out: [DSASheeeet](https://dsasheeeet.vercel.app/home)
No Auth Required.

Everything you need, all in one place!

My Interview Experience: Docusign (P3), Rubrik (SDE2), Harness (SSE1) | Last 6 Months

Sharing my interview experiences from the last 6 months to help others preparing for SDE2 / Senior Software Engineer roles. The interviews covered DSA, multithreading, LLD, HLD, and behavioral rounds.

Hopefully, this helps someone with their preparation. Feel free to share your experiences and suggestions as well!

1. Docusign — P3

Round 1: DSA

**Q1. Text Editor / String Manipulation**

Design and implement the following operations:

* `insert(string)`
* `print(x)`
* `left(x)`
* `right(x)`
* `backspace(x)`
* `delete(x)`

The question focused on designing a text editor supporting cursor movement and editing operations.

**Q2. Array Optimization**

Given an array of integers and an integer `k`, perform exactly `k` operations to minimize the sum of the array.

In each operation:

1. Remove an element from the array.
2. Divide it by 2 and take the ceiling.
3. Add the updated element back to the array.

Return the minimum possible sum after `k` operations.

Round 2: HLD

Design a Live Tracking Service. Discussed the high-level design of a real-time location tracking system.

Round 3: DSA + Behavioral

Q1. Count Substrings in a Binary String

Given a binary string, count the substrings satisfying both conditions:
All `0`s and `1`s in the substring are contiguous. The number of `0`s and `1`s is equal.

Q2. Behavioral Questions**
Strengths and weaknesses, Other behavioral and experience-based questions

Additional Round: HLD

Design Checkout Service for an E-commerce Platform

Design a distributed checkout system with a focus on:
* Security and authentication
* Distributed system architecture
* Inventory failures
* Payment handling and refunds when inventory allocation fails
* Ensuring reliable transaction processing

2. Rubrik — SDE2

Round 1: Multithreading / Distributed Systems

**Problem: Synchronizing Two Large In-Memory Hash Maps**

There are two nodes:

* One in the USA
* One in Europe

Each node contains an approximately **32 GB hash map** loaded in memory.

**Hash Map Structure:**

* Key: Unique string
* Value:

  * `Data`: String
  * `Version`: Integer (higher version = more recent data)

**Goal:**

Compare the two hash maps and synchronize them so they become replicas of each other.

At most 5% of key-value pairs have discrepancies.

**Conflict Resolution:**

1. If the versions differ, choose the data with the higher version.
2. If the versions are equal but the data differs, the USA node is the source of truth.
3. Assume all keys exist in both hash maps.

**Performance Constraints:**

* Data transfer between nodes is extremely expensive.
* Local computation is extremely cheap.
* Assume a powerful CPU, 128 GB RAM, fast NVMe storage (4 TB+), and high network bandwidth.
* The process runs offline/in the background.
* Latency is not critical, but synchronization must complete within a few hours.
* Multiprocessing can be ignored for this phase.

The main challenge was to minimize data transfer while efficiently identifying and resolving discrepancies.

Round 2: Multithreading / LLD

Design a Thread-Safe Parking Lot System

The parking lot is one-dimensional.

Requirements:

* A car occupies 1 parking spot.
* A truck occupies 2 consecutive parking spots.
* Design a thread-safe system that handles concurrent parking and removal operations.

3. Harness — SSE1

Round 1: DSA

**Q1. String Encoding and Decoding**

Design an encoding and decoding mechanism for strings.

**Q2. Graph / Optimization Problem**

There are `n` cities connected by roads. Each road has a toll price.

The goal is to identify the road whose toll price can be increased such that the average price increase across all routes from city `0` to city `n-1` is maximized.

Discussed the graph-based approach and optimization considerations.

Round 2: LLD

Design an Asynchronous Task Processor

Design an asynchronous task processing system and extend it to support:
* Scheduling tasks for a particular time
* Scheduling tasks at recurring intervals
* Task processing and execution management

Round 3: HLD

Design a Top-N Movie Recommendation System**

Design a system that recommends the top N movies based on views collected over the last 7 days.

Key considerations:
* Tracking movie views
* Time-windowed aggregation
* Identifying top N movies
* Scalability and distributed system design

Finally joining salesforce next weeek. Thankyou community for the help. Hope i'm also doing my part for the same.

I applied to Amazon SDE-1 on January 9 and received the offer on September 21, 2026. About eight months passed between those dates. A lot of it was waiting for the next email.

Community posts helped me prepare, so here's what happened in my process and what each round covered.

Timeline

• Jan 9: Applied for SDE-1, after 50+ other applications.

• Jan 21: Received the online assessment (OA).

• Apr 5: Received an email saying I had qualified through the OA.

• May 6: Received onsite interview confirmation.

• May 8: Completed the first three interview rounds.

• Mid-May: Recruiter confirmed I had cleared those rounds.

• May 29 to Jun 5 to Aug 5 to Aug 6: The fourth round kept getting rescheduled, with roughly two months of silence in the middle.

• Mid-August: Recruiter asked about my notice period and location preference.

• Sep 21: Received the offer.

Online assessment

I had taken Amazon OAs before. In previous attempts I solved the coding questions but didn't move forward. This time I prepared more deliberately for both parts:

1. DSA: The problems can involve DP, greedy algorithms, trees, graphs, two pointers, or binary search, often wrapped in long story-based scenarios (think warehouse routing). I practiced stripping away the story and identifying the underlying pattern quickly.

2. Work Style Assessment: I had previously treated this as an afterthought. Preparing to think through the scenarios in light of Amazon's Leadership Principles felt useful this time. I can't know how Amazon scored my OA or which part changed the result, but I wouldn't neglect this section.

Onsite: Round 1: technical + Leadership Principles

• Trees/graph traversal (BFS), medium; similar in pattern to Rotting Oranges.

• Stack, hash maps, and string parsing, hard; similar in pattern to Parse Lisp Expression.

• Behavioral question about handling a hard deadline while requirements changed.

Onsite: Round 2: technical + Leadership Principles

• Binary search on the answer, medium; Maximize the Confusion of an Exam was the closest comparison I found.

• 1D dynamic programming, medium; similar to House Robber variations.

• A deep dive into a project I had owned end to end.

Onsite: Round 3: technical + Leadership Principles

• 3D DP/state machine, hard; similar to Best Time to Buy and Sell Stock III (at most two transactions). Instead of hardcoding two transactions, I explained a generalized K-transactions solution. The interviewer appreciated that it covered both cases.

• An extended discussion of the GenAI work on my resume: how I use AI in development, agents, workflows, and my past work with them.

The LeetCode problems named above are not the exact interview questions. They're the closest examples I found for the underlying logic. In the coding rounds, I talked through brute force, better approaches, and the optimal approach before writing the final code. I explained time complexity where relevant. That communication seemed to land well with my interviewers. Each round ran beyond an hour, and I was the last candidate to leave the building.

After Round 3, my recruiter said I had cleared the first three rounds and would move to the bar raiser.

Round 4: bar raiser and the waiting game

After the repeated rescheduling and roughly two months of silence, I kept wondering whether I'd missed an email or the role had been filled. The round finally happened on Aug 6.

There were no DSA questions in my fourth round. We went deep into my previous work, architecture, and decision-making. The interviewer kept asking follow-ups: Why this approach? Why multithreading, and how did I know it would help? What alternatives had I considered? What critical feedback had I received, and what exactly changed afterward? It felt like an hour of "why?" questions. I had to explain the decisions behind the work, including the alternatives I'd considered.

How I prepared

I'd been practicing DSA and doing contests for years before this process. For these interviews, I spent more time deriving solutions from patterns, re-solving problems and talking through my reasoning out loud.

If I could only solve a problem because I remembered my old submission, I went back to it. I practiced explaining brute force, the optimization, the final approach and its complexity, including the trade-offs.

For behavioral prep, I used real work stories around Ownership, Dive Deep, Deliver Results and learning from failure. I needed to know the technical details well enough to answer follow-ups instead of relying on a memorized STAR script.

Amazon Interview Questions has more candidate-reported coding and behavioral prompts to practice. Through a process this long, application autofill can also save repeated typing while you keep other applications moving.

Before this offer, I'd sent 50+ applications, had unanswered emails and OAs that went nowhere, and spent almost two years struggling to get interviews. I'm glad this one worked out, but I wouldn't tell someone to put every other search on hold while waiting.

If you've recently interviewed for SDE-1, how did your loop compare? I'm especially curious about coding, project depth and the bar raiser.

Hey everyone,

Instead of blindly grinding random problems, I’ve been trying to learn by matching patterns to the absolute best community-written guides on the LeetCode discuss forums. These are the legendary threads written by people who actually landed FAANG offers, for real interview questions PracHub is an useful resource.

I compiled them all into one master sheet categorized by topic, along with a bonus System Design section at the end. Saving this here so anyone can bookmark it for their interview prep.

🧠 Data Structures & Algorithms Patterns

1. Dynamic Programming

• Ultimate DP Patterns & Categorization

• The Interview Question Guide

• DP for Beginners: Sample Solutions

• How I Solved 241 DP Problems in 7 Months

• 2. Linked List

  • Become a Master in Linked Lists

  • The Definitive Linked List Study Guide

• 3. Two Pointers

  • Solved All Two Pointer Problems in 100 Days

  • Mastering the Two-Pointer Technique

• 4. Stack & Queue

  • A Generic C++ Template for Stack Problems

  • Templates for Monotonic Stacks and Queues

• 5. Graphs

  • Graph Algorithms & Practice Problems

  • Become a Master in Graphs

  • Disjoint Set Union (DSU) / Union-Find Complete Guide

• 6. Prefix Sum

  • The Math Behind O(N) Subarray Sum Equals K

• 7. Sliding Window

  • Maximum Sliding Window Cheatsheet & Template

• 8. Backtracking

  • Backtracking for Beginners

  • A General Approach to Exhaustive Search

• 9. Trees

  • Tree Question Patterns for Placement

  • Master Tree Patterns (Updated)

  • Binary Trees Comprehensive Study Guide

• 10. Recursion

  • Become a Master in Recursion

• 11. Heap / Priority Queue

  • Master Heaps by Solving 23 Questions in 4 Categories

  • Important Heap Patterns with Code Links

• 12. Binary Search

  • A Noob's Guide to Binary Search

  • The Ultimate Powerful Python Binary Search Template

• 13. Greedy

  • The ABCs of Greedy Algorithms

• 14. Bit Manipulation

  • All Types of Patterns for Bits & How to Use Them

• 15. Strings & Matching

  • Collections of Important String Patterns

  • String Matching Algorithms Based Questions

📋 The Ultimate Master Lists

• The Only List You Need for Interview Prep

🏗️ System Design Masterclasses

• Complete System Design Case Studies Bundle

• The System Design Template That Landed Me a Google Offer

• The Object-Oriented Design (OOD) Template That Landed Me a Google Offer

Good luck with the grind! Hope this saves you the hours of digging through LeetCode forums that it took me.

Most people sit down, read a problem, panic, and start typing.

No plan. No structure. Just vibes and hope.

When it does not work they read the solution, think "oh that's clever", and move on. Two weeks later they see a similar problem and panic again.

The issue is not intelligence. It is not even practice.
It is that they never had a repeatable process.

This is that process. Follow it on every problem.
Not just hard ones — every problem, until it becomes instinct.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 1 — READ THE PROBLEM TWICE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

First read: understand what is being asked at a high level.
Second read: extract the specifics.

On the second read, write down:

• What is the INPUT? What type, what size, what range of values?

• What is the OUTPUT? A number, array, boolean, string?

• What are the CONSTRAINTS? (most people skip this — do not)

Ask yourself these questions explicitly:

"Can input be empty?"
"Can values be negative?"
"Can there be duplicates?"
"Is the array sorted?"
"What should I return if no answer exists?"

If the problem does not say, assume the worst case.
Empty inputs exist. Negatives exist. Duplicates exist.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 2 — WORK THROUGH THE EXAMPLES BY HAND
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Do not skip this. Even if the problem looks easy.

Take the first example. On paper or in comments, trace through it
manually. Write out every value at every step.

Why this matters:

• You confirm you understood the problem correctly

• You often see the pattern emerge naturally

• You catch ambiguities before they become bugs

Then make your OWN small example — simpler than the given one.
Something with 3-4 elements you fully understand.

If you cannot trace through the examples manually,
you do not understand the problem yet. Do not start coding.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 3 — IDENTIFY THE PATTERN
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before thinking about an algorithm, identify what TYPE of problem this is.

Use these signals:

Subarray, substring, window → Sliding window, two pointers
Sorted array + search → Binary search
Shortest path, min steps → BFS
All paths, combinations, subsets → Backtracking, DFS
Overlapping subproblems → DP
Always picking max/min greedily → Greedy
Tree traversal → DFS (recursion) or BFS (level order)
Connectivity, groups → Union Find, BFS/DFS
Repeated lookup by key → Hash map
Top K, smallest/largest → Heap (priority queue)
Prefix of strings → Trie
Range queries with updates → Segment tree, Fenwick tree
Return all permutations/subsets → Backtracking

You will not always get it right on the first try.
But naming the category forces your brain to search the right space.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 4 — THINK BRUTE FORCE FIRST
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Always start here. Always.

The brute force is the answer you would give if there were
no time constraint. No clever tricks. Just try everything.

Write it out in plain English, not code:
"For every pair (i, j), check if arr[i] + arr[j] = target."
"For every substring, check if it has all unique characters."
"For every subset, check if its sum equals the target."

This does two things:

1. It confirms you can actually solve the problem correctly

2. It gives you a reference to optimize from

Common brute force patterns:
Try all pairs → O(n²)
Try all triples → O(n³)
Try all subsets → O(2ⁿ)
Try all permutations → O(n!)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 5 — OPTIMIZE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Now look at your brute force and ask:
"What work am I repeating? What can I precompute? What can I skip?"

The most common optimizations:

Repeated lookup → replace with hash map O(n) → O(1) per lookup
Repeated sum → precompute prefix sum O(n) per query → O(1)
Checking all pairs → sort + binary search O(n²) → O(n log n)
Checking all pairs → two pointers (sorted) O(n²) → O(n)
Checking all windows → sliding window O(n²) → O(n)
Recomputing subproblems → memoization / DP exponential → polynomial
Sorting gives structure → sort first, then scan enables binary search / greedy

Ask: "Can I sort first to gain structure?"
Ask: "Can I store something to avoid recomputing?"
Ask: "Can I fix one variable and efficiently handle the rest?"

Work top-down in complexity:
O(n²) → can I get O(n log n)?
O(n log n) → can I get O(n)?
Each step needs a concrete reason, not a guess.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 6 — VERIFY COMPLEXITY BEFORE CODING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Before writing code, check:
Does my approach fit within the time limit given the constraints?

n = 10⁵ and my approach is O(n²)? → TLE, think again
n = 10⁵ and my approach is O(n logn)? → fine, proceed

This takes 10 seconds and saves you from coding the wrong solution.

Also check space:
Am I using O(n) extra space? Is that acceptable?
Does the problem say "in-place" or "O(1) space"?

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 7 — CODE THE SOLUTION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Only now do you start writing code.

Code in this order:

1. Handle edge cases first (empty input, single element, etc.)

2. Write the main logic

3. Return the result

Keep variable names meaningful. Debugging unreadable code mid-contest
costs more time than typing three extra characters.

If you get stuck coding:
Go back to your manual example from Step 2.
Trace through it again, this time following the code you are writing.
The bug almost always appears within the first five traces.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
STEP 8 — TEST BEFORE SUBMITTING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Run through these test cases mentally or using the custom test:

[ ] The given examples → obvious baseline
[ ] Empty input → does it crash?
[ ] Single element → does it return correctly?
[ ] All same elements → does duplicate logic break?
[ ] Already sorted input → common hidden test
[ ] Your own small manual example → trace step by step

If all pass, submit with confidence.
If one fails, the failure tells you exactly where the bug is.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
WHEN YOU ARE COMPLETELY STUCK — THE UNSTICKING PROTOCOL
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Everyone gets stuck. The difference is what you do next.

1. Draw it Almost every problem is easier when visualized. Array: draw boxes. Tree: draw nodes and edges. Graph: draw circles and arrows. Matrix: draw a grid. A picture reveals structure that text hides.

2. Simplify the problem Solve a smaller version first. Two elements instead of n. One row instead of a grid. Can you solve n=2? n=3? Then generalise.

3. Try a different angle on your brute force Change the loop variable. Instead of "for each starting index" try "for each ending index". Instead of "for each element" try "for each pair". A different enumeration often reveals the pattern.

4. Check what is special about valid answers Look at the given examples. What do valid answers have in common? What property separates a valid answer from an invalid one? That property is usually the invariant your algorithm should maintain.

5. Look at the constraints again Small n? Try brute force. Very large n? A linear or log solution must exist. "Return modulo 10⁹+7"? It is a DP counting problem. Constraints are hints — re-read them with fresh eyes.

6. Take a 5-minute break Genuinely. Get up. Walk. The solution appears when you stop forcing.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
THE FULL FRAMEWORK — ONE PAGE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Step 1 Read twice. Extract input, output, constraints.
Ask: empty? negative? duplicates? sorted?

Step 2 Trace examples by hand.
Make your own small example. Understand before coding.

Step 3 Name the pattern.
Subarray → sliding window. Shortest path → BFS. Etc.

Step 4 State the brute force in plain English.
What is the O(n²) or O(2ⁿ) solution?

Step 5 Optimize.
What work repeats? Hash map, prefix sum, sort, DP, two pointers?

Step 6 Verify complexity against constraints.
Will it pass? Check before writing code.

Step 7 Code it.
Edge cases first. Then main logic. Then return.

Step 8 Test: examples + empty + single + all-same + sorted.
Then submit.

Stuck? Draw it. Simplify. Try different enumeration.
Re-read constraints. Take a break.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

A correct solution written slowly beats a fast solution written wrong.

The goal is not to code faster.
The goal is to think clearer — so that what you code is right the first time.

This framework is that thinking, made repeatable.

Interview prep resource: PracHub

Hi everyone!

I'm a software engineer with 3+ years of experience, looking for a study partner who's also serious about growing technically and preparing for the next stage of their career.

I'm planning to focus on:

\- DSA: Problem-solving, patterns, and interview preparation

\- System Design: LLD, HLD, and designing scalable systems

\- AI/LLMs: Exploring AI concepts, LLMs, and building projects

I'm looking for someone who's also working in tech or has a similar level of experience. We don't need to have the same goals or study the same topics.

The idea is to keep each other accountable, set weekly goals, have focused study sessions, discuss problems, and share progress. Ideally, we can connect regularly over Discord or another online platform.

I'm not looking for a mentor or someone to teach me everything — just a like-minded person who's willing to put in consistent effort and grow together.

If this sounds like something you'd be interested in, feel free to comment. Let's get better together! 🤝

Edit: Added enough members in the group.

Sharing an interview experience from our Chinese community who recently landed an L7-equivalent role at one of Meta, Anthropic, Nvidia, Google, OpenAI, or SpaceX.

Background

• 19 years of total experience

• Prior Big Tech experience, though not at this tier

• Recruiter reached out directly several months ago

Interview process

• 9 interviews total

• Included recruiter screen, technical screens, onsite/loop, and post-loop conversations

Prep

• Around 120 hours of preparation

• Used blogs, Claude, and LeetCode

• Did 15 paid mock interviews, spending roughly $5,000 in total

Main areas of focus

• Answering behavioral questions at true L7 scope

• Moving away from an overly technical communication style

• Solving system design and architecture problems quickly while demonstrating senior-level judgment

One interesting takeaway was that the biggest challenge wasn’t necessarily technical depth, but communicating at the right level of scope and ownership for an L7-equivalent role.

Curious if others who have interviewed at this level had a similar experience.

Prep Resource LeetCode

I want advice on how to get an internship by the end of my 3rd year. So far, I haven't done much. In my 1st year, I only learned frontend development, and that's about it.

My interview prep journey — what worked for me: LeetCode & PracHub Interview Questions

In the last 1 month, I went through interviews with Nielsen, New Relic and Crunchyroll and received offers from all.

I had been struggling with interviews for quite some time, so I wanted to share what worked for me. There wasn't one magic resource — it was a combination of a few things.

1. DSA

I focused more on patterns rather than solving hundreds of questions.

Arrays, HashMap, sliding window, two pointers, binary search, trees, graphs, heaps, DP, etc.

During practice, I also started explaining my approach out loud — brute force → optimization → complexity → edge cases.

This helped a lot during actual interviews.

1. LLD

LLD was initially one of my weaker areas.

I practiced problems like Parking Lot, BookMyShow, Elevator, Vending Machine, Splitwise, etc.

Instead of memorizing solutions, I focused on SOLID, design patterns, composition/inheritance, interfaces and extensibility.

The goal was to be able to design something I hadn't seen before.

1. HLD / System Design

I practiced systems like URL Shortener, Rate Limiter, Notification System, File Storage, WhatsApp, etc.

The biggest improvement was learning to explain why I was choosing something, rather than just saying "use Kafka/Redis/Elasticsearch."

I prepared for scaling, failures, retries, consistency, caching, partitioning and trade-offs.

1. Project Deep Dive

This was probably the most important part for me.

I went extremely deep into my projects — architecture, data flow, Kafka, MongoDB, Elasticsearch, LLM integration, retries, DLQs, scaling, monitoring, failures, etc.

I also made sure I could clearly explain what I personally built, not just what the overall team built.

This helped significantly in HM and technical deep-dive rounds.

1. Java / Backend

I revised the fundamentals rather than trying to learn new frameworks.

Java Collections, HashMap internals, concurrency, JVM basics, Spring Boot, Kafka, Redis, databases and distributed systems.

Since these were technologies I had actually worked with, going deeper into the fundamentals was much more useful than learning something completely new.

1. Behavioral / HM

I prepared a few real stories around ownership, conflict, production issues, failure, ambiguity and cross-team collaboration.

I used STAR as a structure but didn't memorize answers word-for-word.

For experienced candidates, I think being able to clearly explain what you did, why you did it and what happened afterward matters a lot.

1. Mock Interviews

One thing that helped me was actually speaking through answers.

I'd pick a topic and ask myself follow-up questions:

Why Kafka?
What happens if a consumer crashes?
Why MongoDB instead of PostgreSQL?
How would you scale this?

This exposed gaps much faster than just reading notes.

Final takeaway

There wasn't one resource or trick that got me through the interviews.

For me, it was:

DSA + LLD + HLD + strong project knowledge + Java/backend fundamentals + mock interviews.

And probably the biggest lesson I learned:

Don't just prepare to solve interview questions. Prepare to explain the engineering decisions you've made in your actual work.

Hope this helps someone who's currently preparing. All the best! 🚀

for a long time i thought the way to get better at dsa was pretty simple

solve more problems.

so i did..

100 became 200
then 300
then 400+

but at some point someone asked me:

"what are ur weakest dsa patterns?"

i genuinely didn't know.

i knew my solve count.
i knew my rating.
i could tell you which sheets i'd done.

but if you gave me a blank page and asked me to write down the 3 patterns i was actually bad at, i'd probably just sit there lol.

then i started paying attention to something else.

sometimes i'd solve 5 problems from the same pattern and still get stuck on basically the same idea.

meanwhile i'd look at my profile and think "damn.. 450+ solved. i'm doing pretty good."

but then i'd get stuck on some random medium i've basically seen before 😭

how do you guys actually know when you've learned a pattern?

is it after 5 problems?
10?
when you can recognize it without hints?

because i'm starting to think solve count doesn't really tell you that much.

that's actually what made me build GrindLens.

i wanted to know what i'd actually learned, where i was still weak, and what i should solve next.

so it looks at your leetcode history and tries to surface those gaps instead of just giving you another number.

it's live now if anyone wants to try it:

grindlens.dev

kinda curious what yours looks like lol

In 2nd year.

I have been solving for the last 2 months, I started on 19th Jun.

I'm solving things by reading about things on google or using AI Explanation.

I usually give 2-3 hours on a new topic brainstorming on my own and take hints from Ai after failing and in some cases I solve after getting hints and in some cases I couldn't, then I ask AI to explain the code and dry run it.

Ik it's a lengthy process , I feel i retain more this way

I'm following the LEETCODE 75 STUDY plan .

Open To advice

I graduated 5 months ago. I have been doing DSA for 2.5 years but still not good at it. I used to look to solutions everytime and ended up doing so many questions and feeling boasted about that. From past 6 months I have been changing language of DSA too. I solved dsa with python with 1.5-2 years straight and then doing with java and from past 2 months with C++. I am completely confused. It's not like I am 100% dull I eventually ended up crammed a ton of questions and the questions from most asked DSA questions I remember most of them but I am null when watching a new problem. I am unemployed what to do now so that I can clear OA rounds and get a job. How do I solve DSA. Note: I tried all those advices such as so these 15-20 coding patterns and multiple DSA sheets etc but still ended up mugging up solutions. ALso I am crystal clear I will never solve DSA with Java at least

After getting wrecked by a graph question I absolutely should've recognized, I spent a few months organizing every graph problem I could find by underlying pattern instead of by difficulty. Sharing the structure — worked through pattern by pattern, it's roughly a 2.5-month roadmap.

How to use it: for each new pattern, read the solution for the first 1–2 problems to get the intuition, then solve the rest yourself. That's where the learning happens — in recognizing the pattern cold, not in reading.

If you have an upcoming interview grind on these Leetcode Problems and PracHub for recent interview questions asked by FAANG.

Side note: BFS vs DP identification trick

• When keywords are minimum / smallest...

• For Both BFS and DP, same state can be achieved from two different ways

• For BFS Cycles present in graph, for DP no cycles, forms a DAG

• DP vs BFS example :

• https://leetcode.com/problems/jump-game-iii/description/ (Contains cycle so BFS)

• https://leetcode.com/problems/jump-game-ii/ (No cycle, forms DAG, so DP)

• https://leetcode.com/problems/jump-game-iv/description/ (Contains cycle so BFS)

• https://leetcode.com/problems/minimum-path-sum/ (No cycle, forms DAG, so DP)

• https://leetcode.com/problems/shortest-path-in-binary-matrix/description/ (Contains cycle so BFS)

• Most minimum DP questions can be solved using BFS. But viceversa is not true - ex: https://leetcode.com/problems/coin-change/description/ Can be solved using both DP and BFS

UF + Vanilla

1. https://leetcode.com/problems/lexicographically-smallest-equivalent-string/description/ (soln)

2. https://leetcode.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/description/ (soln)

3. https://leetcode.com/problems/redundant-connection/description/ (soln)

4. https://leetcode.com/problems/number-of-operations-to-make-network-connected/ (soln)

5. https://leetcode.com/problems/making-a-large-island/ (soln)

6. https://leetcode.com/problems/satisfiability-of-equality-equations/ (soln)

7. https://leetcode.com/problems/minimize-malware-spread/ (soln)

8. https://leetcode.com/problems/minimize-malware-spread-ii/description/ (soln)

9. https://leetcode.com/problems/maximum-points-activated-with-one-addition/description/ (soln)

10. https://leetcode.com/problems/properties-graph/description/ (soln)

UF + swaps

1. https://leetcode.com/problems/smallest-string-with-swaps/description/ (soln)

2. https://leetcode.com/problems/make-lexicographically-smallest-array-by-swapping-elements/ (soln)

3. https://leetcode.com/problems/minimize-hamming-distance-after-swap-operations/description/ (soln)

UF + Select edges within a limit

1. https://leetcode.com/problems/checking-existence-of-edge-length-limited-paths/description/ (soln)

2. https://leetcode.com/problems/maximum-number-of-points-from-grid-queries/description/ (soln)

3. https://leetcode.com/problems/number-of-good-paths/description/ (soln)

UF + Factors of numbers

1. https://leetcode.com/problems/gcd-sort-of-an-array/description/ (soln)

2. https://leetcode.com/problems/graph-connectivity-with-threshold/ (soln)

3. https://leetcode.com/problems/largest-component-size-by-common-factor/description/ (soln)

4. https://leetcode.com/problems/greatest-common-divisor-traversal/description/ (soln)

UF + Binary search

1. https://leetcode.com/problems/minimum-time-for-k-connected-components/description/ (soln)

2. https://leetcode.com/problems/minimize-maximum-component-cost/description/ (soln)

3. https://leetcode.com/problems/last-day-where-you-can-still-cross/description/ (soln)

UF + Modified MST

1. https://leetcode.com/problems/min-cost-to-connect-all-points/description/ (soln)

2. https://leetcode.com/problems/maximize-spanning-tree-stability-with-upgrades/description/ (soln)

weighted UF

1. https://leetcode.com/problems/incremental-even-weighted-cycle-queries/description/ (soln)

BFS + Vanilla

1. https://leetcode.com/problems/jump-game-iii/description/ (soln)

2. https://leetcode.com/problems/get-watched-videos-by-your-friends/description/ (soln)

3. https://leetcode.com/problems/shortest-path-in-binary-matrix/description/ (soln)

4. https://leetcode.com/problems/minimum-moves-to-move-a-box-to-their-target-location/description/ (soln)

5. https://leetcode.com/problems/jump-game-iv/description/ (soln)

6. https://leetcode.com/problems/nearest-exit-from-entrance-in-maze/description/ (soln)

7. https://leetcode.com/problems/snakes-and-ladders/description/ (soln)

BFS + Finite states

1. https://leetcode.com/problems/open-the-lock/description/ (soln)

2. https://leetcode.com/problems/lexicographically-smallest-string-after-applying-operations/description/ (soln)

3. https://leetcode.com/problems/minimum-genetic-mutation/description/ (soln)

4. https://leetcode.com/problems/word-ladder/description/ (soln)

5. https://leetcode.com/problems/sliding-puzzle/description/ (soln)

BFS + Multisource

1. https://leetcode.com/problems/01-matrix/description/ (soln)

2. https://leetcode.com/problems/map-of-highest-peak/description/ (soln)

3. https://leetcode.com/problems/rotting-oranges/description/ (soln)

4. https://leetcode.com/problems/as-far-from-land-as-possible/description/ (soln)

BFS + Dikstra

1. https://leetcode.com/problems/path-with-minimum-effort/description/ (soln)

2. https://leetcode.com/problems/swim-in-rising-water/description/ (soln)

3. https://leetcode.com/problems/find-all-people-with-secret/description/ (soln)

4. https://leetcode.com/problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid/description/ (soln)

5. https://leetcode.com/problems/second-minimum-time-to-reach-destination/description/ (soln)

6. https://leetcode.com/problems/shortest-distance-after-road-addition-queries-i/description/ (soln)

7. https://leetcode.com/problems/network-delay-time/description/ (soln)

8. https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/description/ (soln)

9. https://leetcode.com/problems/find-edges-in-shortest-paths/description/ (soln)

BFS + Topological

1. https://leetcode.com/problems/find-eventual-safe-states/description/ (soln)

2. https://leetcode.com/problems/course-schedule-ii/description/ (soln)

3. https://leetcode.com/problems/course-schedule/description/ (soln)

BFS + previous state

1. https://leetcode.com/problems/shortest-path-with-alternating-colors/description/ (soln)

2. https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/description/ (soln)

BFS + Bitmask

1. https://leetcode.com/problems/shortest-path-visiting-all-nodes/description/

2. https://leetcode.com/problems/shortest-path-to-get-all-keys/description/ (soln)

DFS + Vanilla

1. https://leetcode.com/problems/count-the-number-of-complete-components/description/ (soln)

2. https://leetcode.com/problems/keys-and-rooms/description/ (soln)

3. https://leetcode.com/problems/max-area-of-island/description/ (soln)

4. https://leetcode.com/problems/count-servers-that-communicate/description/ (soln)

5. https://leetcode.com/problems/count-sub-islands/description/ (soln)

6. https://leetcode.com/problems/maximum-number-of-fish-in-a-grid/description/ (soln)

7. https://leetcode.com/problems/number-of-closed-islands/description/ (soln)

8. https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/description/ (soln)

9. https://leetcode.com/problems/reachable-nodes-with-restrictions/description/ (soln)

10. https://leetcode.com/problems/number-of-islands/description/ (soln)

11. https://leetcode.com/problems/count-islands-with-total-value-divisible-by-k/description/ (soln)

DFS + Boundry

1. https://leetcode.com/problems/number-of-enclaves/description/ (soln)

2. https://leetcode.com/problems/surrounded-regions/description/ (soln)

3. https://leetcode.com/problems/pacific-atlantic-water-flow/description/ (soln)

DFS + island Perimeter

1. https://leetcode.com/problems/island-perimeter/description/ (soln)

DFS / BFS + Cycle

1. https://leetcode.com/problems/detect-cycles-in-2d-grid/description/ (soln)

2. https://leetcode.com/problems/longest-cycle-in-a-graph/description/ (soln)

3. https://leetcode.com/problems/shortest-cycle-in-a-graph/description/ (soln)

DFS + edge reversals

1. https://leetcode.com/problems/reorder-routes-to-make-all-paths-lead-to-the-city-zero/description/ (soln)

2. https://leetcode.com/problems/minimum-edge-reversals-so-every-node-is-reachable/description/ (soln)

DFS / BFS + Binary Search

1. https://leetcode.com/problems/find-the-safest-path-in-a-grid/description/ (soln)

2. https://leetcode.com/problems/minimize-the-maximum-edge-weight-of-graph/description/ (soln)

3. https://leetcode.com/problems/minimum-threshold-path-with-limited-heavy-edges/description/ (soln)

DFS + DP

1. https://leetcode.com/problems/number-of-increasing-paths-in-a-grid/description/ (soln)

2. https://leetcode.com/problems/longest-increasing-path-in-a-matrix/description/ (soln)

Bipartite

1. https://leetcode.com/problems/is-graph-bipartite/description/ (soln)

2. https://leetcode.com/problems/divide-nodes-into-the-maximum-number-of-groups/description/ (soln)

3. https://leetcode.com/problems/possible-bipartition/description/ (soln)

4. https://leetcode.com/problems/incremental-even-weighted-cycle-queries/description/ (soln)

Full list (all ~90 problems with clickable links + worked solutions for the first 1–2 of each pattern)

Anyone interested in learning DSA with Java together?

I’m looking for a few people who genuinely want to learn .Data Structures & Algorithms using Java and, more importantly, actually stay consistent.

This is not for complete Java beginners, you should have a basic understanding of Java already. The goal is to learn DSA from the fundamentals, practice regularly, solve problems, and keep each other accountable.

The main idea is simple:

\* 📚 Learn DSA step by step

\* 💻 Practice coding/problems regularly

\* 🔥 Stay consistent

\* 🤝 Motivate and help each other

\* 🚫 No unnecessary excuses for skipping

\* 🎯 Keep each other accountable and disciplined

I don’t want this to be another group where everyone is motivated for 2–3 days and then disappears. 😭

If you genuinely want to learn DSA and are willing to put in the effort consistently, let’s do it together.

If you're interested, comment below or DM me. Let's build the discipline together.

Cpp

I got placed at TCS Digital, but honestly, after getting placed, I haven't practiced coding or DSA for the last 4 months.

Now I want to restart, rebuild my problem-solving muscle memory, and consistently grind LeetCode to target better opportunities at companies like Infosys,other product-based companies where DSA and problem-solving skills matter.

I'm looking for genuine and disciplined people who have similar goals.

Group Rules:

- Solve LeetCode problems daily.

- Share your daily progress without fail.

- Discuss approaches, doubts, and optimized solutions.

- Maintain consistency and accountability.

- Inactive or inconsistent members will be removed.

I don't want a huge group full of inactive members. I want a small community of serious people who push each other to improve.

Interested? DM me or comment below, and I'll add you to the group.

Let's rebuild our coding habits and grind together! 🔥

Consistency over motivation. No excuses.

I will accept only the people who are genuine DM your leetcode ID

Group link

https://chat.whatsapp.com/HvQb1LXwIbuKLd3Ywt0eZH?s=cl&p=a&mlu=4&ilr=4&iam=2

Hi everyone! I have 3 years of work experience and am preparing for interviews over the next two months, focusing on DSA, low-level design (LLD), and high-level design (HLD).

I’m looking for a study partner to stay consistent with and prepare together. We could set goals, discuss problems and designs, and keep each other accountable. If you’re interested, please comment or DM me!

Hi everyone! I'm a 2nd-year student, and I've been learning DSA consistently for the past couple of months. Things were going pretty well initially, but recently, I'm finding it a little difficult to maintain the streak and stay consistent.

So, I'm looking for 1–2 people who are also learning DSA and would like to be accountability partners.

The idea is pretty simple: at the end of each day, we can share a quick update about:

What we studied/practiced that day

How much we completed

What we're planning to do the next day

I feel that having someone to report to at the end of the day would give me that extra push to stay consistent, instead of procrastinating. 😅

Preferably: 2nd or 3rd-year students, but I'm open to anyone who's serious about staying consistent with DSA.

My Preparation Strategy

1. Choose one topic and identify all its patterns

Eg., Two Pointers: unidirectional pointers, opposite-end pointers, and three pointers

2. Learn each pattern with ChatGPT

If I still struggle, I’ll explore other resources, such as YouTube, blogs, and webs

3. Solve LeetCode problems related to that topic until I genuinely understand the concept

Then choose the next topic, repeat.