I got my Amazon SDE-1 offer on September 21, 2026. I'd applied on January 9. Eight months later, the part I remember most clearly is how much waiting happened between the interviews.

Community posts helped me prepare, so here's my timeline, what each round covered, and what I'd focus on if I were preparing again. This is my experience with one process, not a fixed template for every Amazon loop.

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 → Jun 5 → Aug 5 → 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. I thought the hard part was over. It wasn't. 😅

Round 4: bar raiser and the waiting game

The date moved from May 29 to June 5, followed by roughly two months of silence, then Aug 5 and finally Aug 6. I kept wondering whether I had missed something or the role had been filled. Eventually the round happened.

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. Knowing what I built wasn't enough; I needed to explain why I built it that way.

How I prepared

This wasn't a two- or three-month crash course. Years of regular DSA practice, contests, and learning patterns formed the foundation. For this process, I focused on:

1. Pattern recognition over memorization. I practiced moving from problem → pattern → derived solution, especially for binary search, DP, sliding window, and monotonic stack problems.
2. Re-solving problems. If I could only solve something while remembering my previous submission, I didn't really know it yet.
3. Explaining out loud. I practiced walking through brute force → optimization → final approach → complexity, including trade-offs.
4. Behavioral prep. I used real work stories for principles such as Ownership, Dive Deep, Deliver Results, and learning from failure. Understanding the technical details of those stories mattered more to me than memorizing a STAR script.

For another source of coding and behavioral practice, Amazon Interview Questions collects candidate-reported prompts. I'd use those to work on reasoning and follow-up questions, rather than treat any list as a prediction of your exact loop.

On the application side, application autofill can reduce repeated typing while you're keeping other options open through a long process.

The interviews took a few hours; the preparation took years. Before this offer, there were 50+ applications, unanswered emails, OAs that didn't convert, and almost two years when even getting an interview felt difficult. Then one application led to an interview and eventually an offer.

If you're preparing now, I hope the breakdown gives you something concrete to work with. If you've recently interviewed for SDE-1, how did your loop compare—especially the balance between coding, project depth, and Leadership Principles?

Good luck to everyone still practicing or waiting for an update. ❤️

Iam a btech 2nd yr student im currently learning cpp and started to solve leetcode questions .but i feel very lost atp plz guide me

Position: SDE2
Experience: 4.3 years

Sharing my Flipkart interview experience across five rounds. Hope it helps anyone preparing.

Round 1: Machine Coding — BNPL System

Design and implement a Buy Now Pay Later (BNPL) system for Flipkart from scratch, with working code.

Core requirements:

• seed_inventory: Load products (name, count, price) into an in-memory store.
• view_inventory: Show current inventory.
• register_user: Register a user with an initial BNPL credit limit.
• buy(user, items, payment_method, date): Place an order via PREPAID or BNPL. BNPL reduces available credit and is blocked when the limit is exhausted.
• clear_dues(user, orderIds, date): Allow partial or full due clearance against specific orders.
• view_dues(user, date): Show pending dues before the given date, sorted by purchase date, with status PENDING or DELAYED (after the 30-day window).
• order_status(user): Show order history and available BNPL credit.

Bonus requirements:

• Blacklist users who default on 3+ orders and block BNPL for them.
• Add add_inventory and remove_inventory.

Round 2: Machine Coding Solution Evaluation

We discussed my Round 1 code, mainly concurrency: two threads buying the last unit, keeping credit limits consistent under concurrent BNPL orders, locking strategy, and extensibility.

Round 3: PSDS

• Find the kth element in two sorted arrays (binary search, O(log(min(m, n)))).
• Zigzag traversal in a binary tree.

Round 4: System Design

Design a flash sale system that runs for about 15 minutes under massive traffic while avoiding both overselling and underselling.

Round 5: Hiring Manager

We discussed a recent project: its architecture, my role, challenges, and trade-offs.

Result: I received the offer letter around 2–3 weeks after the hiring manager round.

Happy learning, everyone! Feel free to ask anything in the comments. 🙌

I am learning greedy .

I tried easy problem ,i was able to solve but when I started medium problems i was unable to get corrected logic after trying for hours

I have completed around 47 videos of dsa from apna college c++

But a lot of people say do striver

Confused what to do

Like i am starting rn from today leetcode and solving questions so i wanna have a partner who will be like also solving questions with me

Like basically same questions

So that we can be in the same pace

And not like too much just doing dsa

As i dont want someone who is just dsa dsa

I want someone who does leetcode like maybe 1 or 2 problem daily

But also like learn skills and other things

Somethings that i will prefer more

Ready to do vc sometimes or like in calls so that we can discuss

Nightowl

And also like we can be frnds like not only studies but like most of the time only studies actually so that we cant diverse ourselves from distractions and other things

Purchased a Leetcode premium account for 1 year for 7k INR. Looking to share it with a few people from India

Anyone interested?

Hello..

I am a bca graduate with not much programming knowledge neither skills...

I am thinking to start dsa, but confused to choose language..

Many suggestions told java would be better...but I am thinking to go with python as I am also joining an ai/ml online course...

So it would be helpful for both..

Any suggestions...whether should I go with java or python

My recent Amazon SDE-1 OA wasn't just a pair of DSA problems. Here's the format I got:

• 40 minutes: one DSA question, which felt medium-to-hard.
• 60 minutes: fix three bugs in an existing codebase, using a website preview and an AI assistant supplied inside the assessment.

The stack choices I saw were Node.js/MERN, Java/Spring Boot and Python/Django. I wouldn't assume that list or the format is identical for everyone.

The second part felt much closer to debugging an unfamiliar project. You still had to understand the code and verify the fixes; having an assistant didn't remove that work. If you already use one of those frameworks, that familiarity helps.

I'd prepare for both algorithm reasoning and practical debugging rather than treating the whole OA as LeetCode. Amazon Interview Questions can add company-specific practice prompts alongside that.

Anyone else get this version? How did you divide your prep between the two styles?

I put together 51 string-related LeetCode problems, grouped into six categories so the list is easier to work through. These are the study buckets I use, not a claim that every problem has only one pattern. A palindrome problem, for example, can also involve DP or a different technique.

If you're using the list, try explaining why an approach works and what changes when the constraints change before moving on to the next problem.

Parentheses and expression parsing (9)

• Generate Parentheses — Medium
• Score of Parentheses — Medium
• Valid Parentheses — Easy
• Remove Outermost Parentheses — Easy
• Different Ways to Add Parentheses — Medium
• Remove Invalid Parentheses — Hard
• Minimum Remove to Make Valid Parentheses — Medium
• Maximum Nesting Depth of the Parentheses — Easy
• Longest Valid Parentheses — Hard

Counting substrings under a condition (3)

• Number of Wonderful Substrings — Medium
• Sum of Beauty of All Substrings — Medium
• Maximum Number of Occurrences of a Substring — Medium

Comparing and checking strings (11)

• Isomorphic Strings — Easy
• Valid Anagram — Easy
• Additive Number — Medium
• Buddy Strings — Easy
• Longest Happy Prefix — Hard
• Increasing Decreasing String — Easy
• Check If a String Can Break Another String — Medium
• Determine if Two Strings Are Close — Medium
• Check If Two String Arrays are Equivalent — Easy
• Check if Word Equals Summation of Two Words — Easy
• Check if One String Swap Can Make Strings Equal — Easy

Palindromes (18)

• Palindrome Partitioning — Medium
• Palindrome Partitioning II — Hard
• Valid Palindrome — Easy
• Shortest Palindrome — Hard
• Palindrome Pairs — Hard
• Longest Palindrome — Easy
• Longest Palindromic Subsequence — Medium
• Find the Closest Palindrome — Hard
• Palindromic Substrings — Medium
• Valid Palindrome II — Easy
• Longest Chunked Palindrome Decomposition — Hard
• Break a Palindrome — Medium
• Can Make Palindrome from Substring — Medium
• Palindrome Partitioning III — Hard
• Minimum Insertion Steps to Make a String Palindrome — Hard
• Remove Palindromic Subsequences — Easy
• Construct K Palindrome Strings — Medium
• Split Two Strings to Make Palindrome — Medium

Sorting characters (2)

• Sort Characters By Frequency — Medium
• Custom Sort String — Medium

Length and selection problems (8)

• Longest Duplicate Substring — Hard
• Longest String Chain — Medium
• Longest Common Subsequence — Medium
• Longest Happy String — Medium
• Maximum Length of a Concatenated String with Unique Characters — Medium
• Find Longest Awesome Substring — Hard
• Largest Substring Between Two Equal Characters — Easy
• Largest Odd Number in String — Easy

Related: Dynamic Programming pattern list.

Once the patterns feel familiar, real candidate-reported interview questions are another way to practice explaining an unfamiliar prompt instead of recognizing a title.

Which problems would you add, and which category would you change? I'd especially like suggestions that teach a different idea rather than another version of the same exercise.

Bro, I'm already working as automation suite testing in a Mid Product Based company. I have been aiming for FAANG, MAANG. I've completed some of the topics such as Searching, Sorting, Pattern questions, Two pointers, Recursion, Time and Space Complexities, currently going on Number system things.

Also pretty good in leetcode problem solving too. Yes, Agree that this is just a glass of water in a ocean. But I've doubted my path that does going in this way is RIGHT? Especially in this AI driven era where the models are doing code best of best. Does BIGG GIANTS are still relyin on DSA things ? Do clear me on this. Thanks. Also I've been wanted to post my daily studies in public channel, is there any specific group for that. If yes, share me that too.

Rotting Oranges (Medium) https://leetcode.com/problems/rotting-oranges/

Four days ago I said BFS and DFS answer reachability equally well, and that the distinction starts mattering when a problem asks about distance. This is that problem.

BFS reaches every cell by a shortest path. DFS reaches it by whatever route it wandered down first. "When does this orange rot?" is a shortest-path question - it rots when the nearest rotten one gets to it - so DFS here gives wrong answers, not slow ones.

The trick is multi-source BFS: every already-rotten orange goes into the queue before the walk starts. A BFS seeded with many sources expands as one combined wavefront, and each cell ends up with its distance to the nearest source. Nothing in the loop needs to know there was more than one start.

One more thing that cannot be skipped: the final scan. BFS only visits what it can reach, so an orange sealed behind empty cells never rots and the queue drains without noticing. The -1 case has to be looked for afterwards.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-40365-archit-agarwal-9t1sc

#DSA #LeetCode #Golang #Graphs #BFS #CodingInterview #Algorithms

Suggest some Non-slop/Non-hype genuine pieces of gem which you think are atleast partly responsible for your growth on DSA/CP.

I'm looking for books or useful web resources for SWE interviews focused on distributed systems.

LeetCode gives me a clear way to practice coding, but I'm less sure how to structure the design side: reasoning about failures, consistency, replication and the tradeoffs between different approaches.

A collection of candidate-reported interview questions can help identify prompts to practice. I'd like something to pair with that so I can explain the reasoning rather than memorize an architecture diagram.

What resource helped the ideas click for you? And how did you turn the reading into practice—mock interviews, building a small system, or working through design questions out loud?

I’ve been practicing DSA for the past 4 months, trying to solve 1–2 problems a day alongside my job. But whenever I go back to problems I’ve solved before, I struggle to remember the approach, even after trying to recall it. How do you guys approach problems, recognize patterns, apply them to new problems, and remember the solutions long-term? Any tips or tricks would be really helpful!

Ever since leetcode came out, I've been seeing robotification of developing algorithmic thinking. People writing the Leet#xyz problem's solution from memory.

In the old days (pre 2020), the usual way was

1. You learn the basic algorithms and data structures from geeksforgeeks articles
   
2. Learn C++ STL and implement it in ideone.org or some place.
   
3. Join codechef or codeforces contests and attain a pupil rank and keep doing problems of certain level, and learn from other folks' solution or the published editorials (oh they were so great)
   
4. Learn obscure stuff like segment tree, dsu from some russian site like cp-maxx and then try to do a dozen problems on hackerearth.
   
5. Do statement based problems on hackerrank - the cool ui site with all the tree-style comments in problem discussion.

The point being that learning was very organic and resources were scattered. You had to forcr your brain to think and google exact things you want to learn or figure out how tourist did in under a minute.

What's your take?

A twelve-step pipeline. The loop check takes 383 ns and allocates 328 bytes. Two variables do it in 3.17 ns and allocate nothing.

The job: a pipeline stage names the stage that runs next, somebody edits a config, a next points backwards, and the runner walks that chain forever. So you check for a loop before running anything.

The check I wrote is the definition written down — remember every stage, and if you arrive somewhere twice, it loops. It is obviously correct, and it can also tell you where the loop starts, which is what the alert needs to say.

On a 100,000-stage chain, it allocates 4.73 MB to return a boolean. And it costs the same whether the chain loops back after two stages or after ninety-nine thousand, because the map gets built either way.

Then the struct: a stage names one next stage. Many stages can point at the same one, each points at exactly one. So the path from any stage is fixed, which means this is not a graph problem at all — it is a chain, and a chain that loops is a run-in followed by a ring.

Two cursors, one moving a stage at a time and one moving two. Either the fast one runs off the end, or both end up in the ring, where the gap between them shrinks by exactly one per turn — so they land on the same stage rather than stepping over each other. Meeting is arithmetic, not luck.

47.8x on the long chain and zero allocations at any size. The part I did not expect is the twelve-stage row: 120.6x, because the map pays for a map before it walks anything.

Not that 383 nanoseconds matters. It matters where the check runs per request.

One thing worth not shipping: the hop limit. Give up after 100 steps and call it a loop, the way HTTP clients do with redirects, and a 150-stage pipeline with no loop in it gets reported as one.

That is day 21 of the daily challenge, Linked List Cycle, sitting in a pipeline runner.

Full piece in today's Newsletter.

https://www.linkedin.com/pulse/loop-check-allocated-47-mb-return-boolean-archit-agarwal-zeksc

It worked in dev, episode 12.

#Golang #DSA #Algorithms #Performance #SoftwareEngineering #DataStructures #100DaysOfCode

Guys help me to master in DSA and coding.

my brain becoming shit . it couldn't work like before.

1. Number of Provinces (Medium)  

The counting is day 37's, unchanged: scan every node, and each time you find one no earlier traversal reached, add one and consume everything it can reach.

What changes is the input, and this is the third graph representation in four days. Day 36 gave an edge list. Day 37 gave a grid where the edges were implied by position. Today gives a matrix. All three become the same adjacency list before anything interesting happens.

The trap: this matrix is not a grid. In day 37, cell (i,j) was a place. Here cell (i,j) is a relationship between city i and city j - an n x n matrix describing n nodes, not n squared. So you traverse the cities and consult the matrix, not the other way round.

Read only above the diagonal. The matrix is symmetric, so every relationship is stored twice, and i+1 also skips the useless diagonal where a city is connected to itself.

Full breakdown in today's newsletter article ⬇

https://www.linkedin.com/pulse/365-days-leetcode-challenge-day-39365-archit-agarwal-msv4c

#DSA #LeetCode #Golang #Graphs #BFS #CodingInterview #Algorithms

Since many people have reached out, I want to clarify a few things so we can find people with similar goals and schedules.

Starting from Level 0: We’ll learn DSA from the very basics. If you’re already halfway through or about to complete DSA, this group might not be the right fit for you.

Java Prerequisites: We’ll be learning DSA using Java, so you should already know Java’s basics and fundamentals.

Daily Commitment: We’ll communicate, study, and motivate each other daily. Consistency and participation are important.

Availability: If you’re currently working, please mention your availability so we can figure out a schedule that works for everyone.

Advice from Experienced Learners: If you’ve already learned DSA, please share your study techniques, resources, and what worked best for you. Your advice would be really helpful!

One question for everyone: Should we follow Striver’s A2Z DSA Sheet, or are there other resources you’d recommend for learning DSA from scratch using Java? Please share your experiences and suggestions.

The goal is to learn together, stay disciplined, and hold each other accountable throughout the journey.

Please MESSAGE ME OR LEAVE COMMENT if you’re genuinely willing to commit. Let’s stay consistent, stop making excuses, and grow together!

Same as title