Sharing my prep and interview experience here in case it's useful for anyone targeting Staff/Senior roles. I applied at more than 500 places. Interviewed at some. Adding few here.

Previous company: UK-based product company (laid off in March due to restructuring)
YOE: 8+
Previous CTC: 69 LPA, All cash + bonus
College: Tier 1, Non-CS

Prep

• DSA: LeetCode Premium, company-wise tagged questions.
• HLD: Jordan / Hello Interview, plus previously asked questions. Go deep into how things like Kafka work internally.
• LLD: There aren't many good resources for Staff-level roles, even solutions on Hello Interview channel are not deep enough for Staff roles. I'd suggest brushing up on the basics, coming up with solutions yourself, and reviewing them with AI.
• I took Linkedin premium, don't think it's useful, referrals are the best way to get shortlisted.

Interview Experiences

Licious — SDE 3

• Machine coding: Build an API following best practices.
• F2F round: Java and Spring Boot basics. I hadn't prepared for this, so I couldn't answer some basic questions.

FirstClub — Tech Lead

• Assignment: Build a rewards microservice for first club.
• I think I built a decent project, but HR ghosted after submission.

Walmart — Senior Engineer (hiring drive)

• Online test: 2 LeetCode medium questions (HackerRank) + some theoretical Java questions, in 1.5 hours.
• DSA round: Easy-to-medium question, solvable using a HashMap.
• LLD round: Design a hospital management system — class diagram, a small implementation, and a discussion on the logic.
• System design round: Design Google Drive.
• Cleared all rounds, but stopped the process cause the Staff loop was also cleared.

Walmart — Staff Engineer

• DSA round: 2 LeetCode medium questions on HackerRank; had to pass all test cases.
• LLD round: Design an access control layer for a SaaS tool. Had to cover RBAC, ABAC, ReBAC, etc., along with the data modelling in the DB.
• System design round: Design a live collaboration tool like Google Docs (had to discuss OT, CRDTs, etc.), including class design.
• AI / HR round: The first 30 minutes covered how I use AI tools, and an AI project I had built (I talked about a project I built for company-wide knowledge sharing). The next 30 minutes was the usual discussion with the manager. Both the manager and HR were extremely helpful and supportive throughout the process.
• Cleared all rounds and received the offer.

ThoughtSpot

• DSA round: LeetCode Hard — median of a stream. I had seen this problem before, so I solved it in 30 minutes and the remaining time went into discussion.
• System design round: This round was taken by a junior developer who wasn't aware of basic practices like maintaining a single source of truth. He kept interrupting throughout, though I handled it politely and explained the correct solution to him.
• Ghosted, I would have rejected this one even if they had made an offer.

Amazon — SDE 3

• DSA round: 2 LeetCode medium questions, Jump game and straight forward dfs graph traversal.

• LLD round: design LFU cache with TTL. I think the trick here is to use composition instead of inheritance. I used an approach where I had an instance of "CachingContext" object with all the applicable Eviction strategies (LFU and ttl for this case). The eviction candidates are devided after applying all the policies according to their priority. I was not able to implement the whole code but part of it, given the complexity.

• HLD round: design a distributed rate limiter for an internal service, that has a fixed throughput limit for each up stream service based on an api key. One api key can be used by more than one service/instances. In case there is a request that cannot be served, that will NOT be rejected but queued somewhere and processed later. There should be no wasted capacity meaning in case there is spare capacity for service-1 the other service-2 that has reached it's capacity limit should utilize it. The service expects 10k RPS and can scale upto 1mil RPS in future.

I gave a solution where I was using redis in clusterd mode (sharded by api key), dedicated shard for hot services that will be spun off preemtively. The capacity utilization will be done by lua script to avoid "check then updated" issue. The requests that are over limit will be queued to different kafka queues, and then executed by worker in the calling service. For sharing spare capacity I suggested we either use historical RL data OR a "service priority/tier list" stored in redis, and during the atomic check and update utilize this.

The real world solution for these kind of problems is to have a central "leasing" service that leases the capacity to individual servers as per request. The servers in case they have reserve capacity push the capacity back to leasing service. The jobs are queued in memory per instance. The down side of this appraoch is that in case your instance goes down the capacity is lost and since the capacity is instance based and even when you have some capacity for an API key, a request can be rejected if it hits the wrong instance.

I did discuss the second approach briefly, when interviewer asked what if I do not want the network latency of calling a redis cluster. The trade offs are: Latency, using capacity fairly for 2 incoming requests, accepting the capacity loss in case of approach 2. job queuing logic is way simpler in approach 2, dev complexity.

Over all a great discussion, learned something new.

Edit2: Initially I opted out of the loop but then the recruiter reached out again, greed took over me so I appeared for rest of the rounds as well. Adding exact details of questions asked.

Oracle Health IC4 (Edit, forgot to add before)

• Round 1 Taken by a manager, discussions around past projects and some scenario based questions.
• Round 2: Design notification service HLD, didn't ask any cross question, or deep dives. I mentioned things like separate queue for critical messages etc.
• Round 3: Behavioral round, Simple scenarios based questions, again a non technical person.
• Round 4: Was caught a bit off guard, didn't prepare much. A very senior technical guy from US team took the interview. Question: Design the search bar for AWS console UI, where people can search services, and the services that are shown can be ranked based on when they were last used. I didn't clarify the requirements and assumed that I have to build the thing from scartch and not use Elasticsearch. Got into the rabbit hole of inverted indexes in dynamo/cassandra, with fuzzy matching logic based on edit distance etc. The main ask was not the feature but the provisioning and deployment of such feature in amazon's control plane.
• Recruiter reached out and told that the team wants to down level to IC3, I rejected that. Later they reached out again for another IC4, loop butI rejected cause they were not matching Walmart's offer.

Rippling — Senior Software Engineer

• Got shortlisted for the interview loop, but cancelled it as Walmart had better WLB.

Others — Senior/Staff Roles

• Cleared a few other startups as well, not mentioning them here, they were paying around 65-70LPA.