Shubham Kumar Deshmukh

A candidate appearing for SDE-II interviews at Amazon was asked the LFU Cache hard LC problem during his coding interview. Another candidate appearing for Senior SWE at Uber was given this problem to solve during his coding interview. 1 failed the interview. 1 landed the offer. The difference? Pattern-based thinking. Let me break it down for this exact question and how it works when you are under pressure, stressed, and the interviewer is watching. Btw, this is the exact skill that I teach with my DSA-pattern Ecosystem, you can check it out here: https://lnkd.in/gqXTkSev 5100+ students are already using it, it has 50+ videos covering each pattern in detail and how to spot it, 250+ handpicked problems mapped to patterns, and you get AI-assisted feedback. [1] Step 1: Decode what the problem is -really- asking - You see: get, put, eviction, and the words "must run in O(1) average time". - That should ring a bell: this is a cache design problem. - Pattern in your head:   - O(1) lookup → HashMap for key to node.   - O(1) eviction according to some policy → Linked list or ordered buckets. If your first thought is "I will scan all entries and find the minimum frequency", you have already lost. That is O(n). [2] Step 2: Name the eviction policy pattern - Here the policy is:   - Remove Least Frequently Used.   - If tie, remove Least Recently Used among those.  - That means we need to track two things at once: frequency and recency. - Pattern:   - HashMap: key → node (value, freq, pointers).   - Another map: freq → doubly linked list of nodes with that frequency, ordered by recency.   - A variable minFreq to know which list to evict from. Once you say this out loud, the interviewer already knows you are on the right track. [3] Step 3: Walk through operations in your head - get(key)   - If key not found, return -1.   - If found:     - Take node out of list freq = f.     - Increase its freq to f + 1.     - Move it to the head of list f + 1.     - If old list becomes empty and f was minFreq, bump minFreq. - put(key, value)   - If capacity is 0, do nothing.   - If key already exists: update value, then treat as get(key) to increase freq.   - Else new key:   - If cache is full:       - Go to list with minFreq.       - Evict the node at the -tail- of that list (LRU among LFU).       - Remove from both maps.     - Insert new node with freq 1 at head of list 1.     - Set minFreq = 1. Notice how every step is O(1) because you never loop over all keys. [4] Step 4: How this looks in an interview under pressure A candidate who fails usually: - Jumps straight to code. - Uses a single map plus a linear scan to find LFU on every eviction. - Realises near the end it is not O(1), gets stuck, starts patching. A candidate who passes does this: - Spends 3–4 minutes talking through the pattern. - Draws: keyMap, freqMap, and a small example of minFreq changing. - Only then writes code that is almost a direct translation of the dry run.

139

9 Comments

𝗧𝗵𝗲 𝗖𝗮𝗿𝗲 𝗮𝗻𝗱 𝗙𝗲𝗲𝗱𝗶𝗻𝗴 𝗼𝗳 𝘆𝗼𝘂𝗿 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗮𝗹 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿. At Amazon, engineers tend to progress from SDE-I → SDE-II → SDE-III (Senior SDE) → Principal Engineer. This somewhat sends the signal that a PE is an “SDE-IV” - which is incorrect. An Amazon, PE is a unique role with a step change in autonomy, impact and scope, and mixes tech, business and people skills. It is not exactly the same as Google L7, Meta E7, Microsoft L67, etc. It is peculiarly amazonian - and that’s why I love being an Amazon PE. When I was promoted to PE in 2014, I learned this because: (1) I had a couple of great managers (hi Dan Sommerfield and Joseph Fitzgerald!) that had experience promoting, managing and growing other PEs at Amazon. (2) Amazon had a vibrant, single PE community (https://lnkd.in/gH_pWDry), which gave me countless opportunities to be involved in the weekly PE lunches, PE Design Reviews, PE Offsites at Suncadia, etc. Being a part of this community, watching how other PEs thought and acted, was essential in calibrating and improving myself. I remember the first few events that I attended, quietly listening and thinking “wow when I grow up I want to be like X.” Back then there were about 250 PEs in the entire company. Today there’s 10x that. So scaling that PE community has been a challenge. This means newly promoted or hired PEs don’t have the same [2] that I had. They may be isolated in a team or an org without exposure to dozens or hundreds of their peers on a regular basis. We’ve also hired a lot of new managers who may not truly understand what makes an Amazon PE unique. Maybe they never managed one, or maybe they managed one in other companies where the expectations are different. This means newly promoted PEs may also not have the same [1] that I had. I worry that without [1] and [2], our PEs may end up being treated as SDE-IVs, which again: they are NOT. I have some ideas, such as ways to replicate the PE community (but more locally - perhaps by org). This is something I think about a lot. Our PEs are essential and peculiar, and I want to keep us that way. If you're a new manager of an Amazon PE: take some time to understand how your PE is not an SDE-IV. If you're a new PE: make the effort to find a community or even build your own.

365

24 Comments

Stripe pays ₹40–50 LPA for SDE-1 and ₹70–90 LPA for SDE-2 roles! 🤯 And here’s an interesting question they might ask: “How would you design a URL Shortener system like Bitly that scales to billions of requests per day?” Things to consider: ✅ Hashing vs Base62 encoding ✅ Collision handling and unique ID generation ✅ Read-heavy architecture and caching layers ✅ Expiry and analytics tracking But here’s the kicker - what if the same long URL is shortened multiple times by different users? Do you generate new short links every time, or return the same one? And how would you keep your service fast while preventing hash collisions across millions of URLs?

204

1 Comment

Stop treating Load Balancers and Reverse Proxies as the same thing. In System Design interviews (and production incidents), the distinction matters more than you think. As we move from SDE1 to SDE2, we stop asking "How do I make this code work?" and start asking "How does this system scale and survive failure?" Here is the deep dive on two critical components that often get conflated. 1. The Load Balancer (The Scaler) Primary Goal: Availability & Horizontal Scaling. The Job: Spreading traffic across multiple compute resources to eliminate Single Points of Failure (SPOF). The SDE2 Nuance: You need to know the difference between Layer 4 (Transport) and Layer 7 (Application) balancing. L4 is fast; it forwards packets based on IP/Port without looking inside. L7 is smart; it terminates the connection, reads the HTTP headers/path, and routes /api differently than /images. 2. The Reverse Proxy (The Shield) Primary Goal: Security, Unification & Offloading. The Job: Sitting in front of backend servers to hide their topology and IP addresses. The SDE2 Nuance: SSL Termination. Decrypting HTTPS handshakes is CPU-intensive. A Reverse Proxy handles this heavy lifting at the edge, allowing your backend application servers to focus purely on business logic (and communicate via HTTP inside the private VPC). The Reality Check 💡 In modern architecture (and cloud environments like AWS ALB or tools like NGINX), the lines blur. We often use a single component to perform both roles simultaneously—terminating SSL (Reverse Proxy) and then distributing the request to a pool of instances (Load Balancer). But knowing which function you are tuning—and why—is what separates a mid-level engineer from a senior one. Questions for the network: Do you prefer handling SSL termination at the Load Balancer level or strictly on the application server for end-to-end encryption? #SystemDesign #SDE2 #SoftwareEngineering #Scalability #DistributedSystems #DevOps

66

1 Comment

Stripe pays around 40-50LPA for SDE-1 and 80-90LPA for SDE-2 role🤯🤯🤯 This is the classic question they generally ask How to prevent double payment if API call fails? There are 3 possible scenarios: - Client sends request, but it never reaches the server – safe to retry. - Client sends request, server starts processing but fails midway – unsafe to retry. - Server successfully processes the request but fails to send response (network issue) – again, unsafe to retry. ⚠️ Retrying in cases 2 or 3 could lead to duplicate payments or multiple orders. So how do you handle this? 🛡️ Idempotency Keys to the rescue! 1. Client first requests a random idempotency key from the server. 2. Every time the client makes an API call, it includes this key. Server checks: 1. If the key exists in Redis (or similar in-memory DB), return the saved response. 2. If not, process the request and store the key + response. These keys have TTL (time-to-live) based on the use case. But what if Redis goes down? 😂 Let me know in comments… There are 3 more issues dekhte hai bta paoge ya nhi comments mein… #stripe #payments

3,555

229 Comments

I have researched lots of product-based companies like Amazon, Stripe, Netflix, Asana, Zomato, Goldman Sachs, Paytm, Reddit, Inc., etc. for SDE-1 and SDE-2 roles, and found that variations of these frontend system design questions show up repeatedly in interviews. 𝐅𝐫𝐞𝐬𝐡𝐞𝐫 𝐋𝐞𝐯𝐞𝐥 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧 1. Design a reusable modal/dialog system for a React application. 2. Design a toast/notification system that works across the entire app. 3. Design a dynamic form builder with nested fields and validations. 4. Design a reusable table/grid component with sorting, filtering, and pagination. 5. Design a drag-and-drop Kanban board like Trello. 6. Design a multi-step wizard form with validation and progress tracking. 7. Design a sidebar/navigation system that supports dynamic menus. 8. Design a theme provider system for dark/light modes. 9. Render a list of 10k+ items efficiently in React. 10. Implement infinite scrolling for large datasets. 11. Prevent unnecessary re-renders in a complex React component tree. 12. Design a search bar with debouncing, suggestions, and result highlighting. 13. Design a reusable file upload component with drag-and-drop support. 14. Design a consistent form validation and error messaging system. 15. Implement keyboard navigation and accessibility for interactive components. 16. Design a responsive dashboard layout with reusable widgets. 17. Optimize images, fonts, and static assets for faster page load. 𝐄𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞𝐝 𝐋𝐞𝐯𝐞𝐥 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧 1. Structure a large-scale React project used by multiple teams. 2. Design a shared component library used across multiple applications. 3. Architect a scalable state management solution for a complex frontend. 4. Design a feature flag / feature toggle system for frontend features. 5. Design a plugin-based dashboard where teams can add widgets. 6. Design a scalable grid/layout system for dashboards and admin panels. 7. Architect a micro-frontend system for multiple React applications. 8. Design a dashboard with resizable and customizable widgets. 9. Design a real-time chat or messaging UI. 10. Design the frontend architecture for a collaborative editor like Google Docs. 11. Implement API caching, retry, and error handling strategies. 12. Design optimistic UI updates for actions like likes, comments, and edits. 13. Implement offline-first support with local storage or IndexedDB. 14. Handle large nested API responses with proper data normalization. 15. Design a scalable internationalization (i18n) system. Over the past few months while preparing myself, I’ve been documenting these patterns, solutions, and interview workflows. Eventually it turned into a Frontend Interview Playbook, covering system design questions like these, machine coding patterns, debugging approaches, and how to use AI effectively during preparation. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗣𝗹𝗮𝘆𝗯𝗼𝗼𝗸 𝗵𝗲𝗿𝗲: https://lnkd.in/d8vBd3_j Use code FRONT10 for 10% off.

65

🚀 LazyConstants in Java JEP 526 brings constants which can be lazily initialized aka Lazy Constants. The concept was in first preview as Stable Values in JDK 25, it has been renamed to Lazy Constants and is in second preview. Lazy constants are treated as true constants by the JVM, which gives us the same immutability benefits as final fields, along with deferred initialization. ✅ Designed for objects which hold immutable data ✅ JVM treats stable values as constants, and you can get similar performance gains as final fields. ✅ Although similar to final fields, they are more flexible when it comes to the timing of initialization. ❓ How do they differ from final fields? ✔️ final fields are primarily used for managing immutability. However, final fields must be set eagerly, either during object construction for instance fields, or class initialization for static fields. ✔️ Even in cases where they are not used, all the final fields will get initialized eagerly. ✔️ Lazy Constants brings “deferred immutability” to us. ❓ How to create Lazy Constants? ✔️ A lazy constant is created using the factory method LazyConstant.of(Supplier) ✔️ When created, the lazy constant is not initialized, which means the constant is not yet set.  ✔️The first time get() is called, the supplier function is executed and the constant value is set. ❓What if multiple threads try to initialize a lazy constant at the same time? ✔️A lazy constant is guaranteed to be initialized atomically and at most once.  ✔️Only one updating thread can run the supplier function, and the other threads are blocked until the constant is initialized. #JavaByte #JavaTip #Java #JDK26 PS: This post is 100% human generated :)

5

One thing your manager will never tell you Your promotion depends less on your performance and more on whether your team is actually growing. When I joined Amazon as an SDE-1, my team had 25 people. By the time I became Senior, it had 120+. Looking back, my “fast promotion” wasn’t magic. The org was expanding like crazy and growth creates opportunity. Here is the part people don’t like hearing: ❌ If your team hasn’t grown in years, your career won’t either. ❌ It doesn’t matter how good you are. There is nowhere to go. ❌ The only real path up becomes waiting for someone above you to leave. So if you want to grow faster: Choose teams that are growing. Not teams that are comfortable. Skills matter. Environment matters more.

1,038

20 Comments

Is CDN a reverse proxy, just like a load balancer or an API gateway? Yes. While LB and API gateway fit the classic definition of a Reverse Proxy, CDN is also a reverse proxy with caching as its primary purpose. Like any other reverse proxy, 1. CDN acts as a single point of entry for client requests, 2. CDN abstracts out different origins configured behind it 3. CDN can also route the requests across multiple origins depending on the route-matching configuration. Hence, the deduction is on point, and LB, API Gateway, and CDN are all examples of Reverse Proxies. I elaborated on CDN, as it is an unconventional example. ps: I love how the comments on my YouTube videos are also no-fluff and filled with thought-provoking questions. Thank you for asking such great questions. By the way, the question was asked in my recent video on Forward and Reverse Proxy. In the video, I went into highly practical details with real-world examples and stories from my life. give it a watch and subscribe - youtu.be/HrG0MHkSsCA btw, enrollments open for sys design June cohort, about 30 seats left - arpitbhayani.me/course

324

8 Comments

Let's say you're in an interview for the SDE-II role at Blinkit and you're asked this LLD question: Design a restaurant food ordering system like Zomato, Swiggy, DoorDash How would you answer it? I'm an Engineering Manager with a deep frontend background across the last 12 years of my career. Here's how I would answer it. [1] What a naive design would do Idea: Store everything in memory or simple files, process orders synchronously. Flow: - User browses restaurants from a single database query - Add items to cart stored only in browser localStorage - Submit order as one big transaction - Poll database every few seconds to check order status Why this breaks down? - Cart state lost if user switches devices or clears browser - No real-time updates when restaurant accepts/rejects order - Concurrent order placement causes race conditions (same item sold out) - No way to handle multiple actors (user, restaurant, delivery partner) updating order state - Single database becomes bottleneck during peak hours (lunch/dinner rush) Just localStorage and polling won't scale for a company like Swiggy or DoorDash. --- [2] What real systems do: event-driven architecture with state machines Core Services: Order Management Service - POST /orders, GET /orders/{id}, PATCH /orders/{id}/status - Order state machine: CREATED → CONFIRMED → PREPARING → READY → PICKED_UP → DELIVERED - Each state transition publishes events to message queue (Kafka/RabbitMQ) Cart Service - Separate service with Redis/Memcached for fast, distributed access - Key: user_id + session_id, value: {restaurant_id, items[], subtotal, taxes} - TTL of 30-60 minutes to auto-cleanup abandoned carts - Syncs to backend on every cart modification so it's available across devices Restaurant Service - Menu management with real-time item availability flags - Inventory checks before order confirmation - Restaurant dashboard subscribes to order events for kitchen display system Delivery Service - Assigns delivery partners using matching algorithms (proximity, ratings, current load) - Tracks location via GPS updates every 10-15 seconds - WebSocket connections push location updates to user's app for live tracking Key Data Models: Order {   id, user_id, restaurant_id,    items: [{item_id, quantity, price, customizations}],   status, delivery_address, payment_id,   timestamps, delivery_partner_id } OrderEvent {   order_id, event_type, actor,    previous_state, new_state, timestamp } Real-time Updates: - Client establishes WebSocket connection when order is placed - Backend pushes status changes: "Restaurant confirmed", "Food is ready", "Partner is 2 mins away" - Fallback to Server-Sent Events (SSE) or long polling for older devices Continued ↓

377

12 Comments

How should I fix this issue on my open source SWE career app? Issue: The list of open to work folks is multiple pages long. Folks several pages back do not get viewed by recruiters. Couple solutions I thought about: 1. Randomize their order. 2. List candidates in freshness order; whoever marked "open to work" most recently. If someone hasn't updated in a while, it's fine they are last in queue. Is there a better solution?

4

19 Comments

Prakhar's HLD for Dropbox's files and folders sharing Prakhar sharing a folder 1. Prakhar right-clicks his "Project Alpha" folder and invites his colleague, Simran, granting her "edit" access     2. His client sends a request to the Share Service to define rules     3. Creating the Share 1. Share Service creates a unique, shared record with File/folder identifier, Access level (view/edit), Recipient email (Simran), Expiration settings (if any) 2. It attaches an Access Control List (ACL) to shared record, marking Prakhar as the owner and adding Simran as an editor 4. Creating a "Link" 1. Share Service contacts with Metadata Service to place a special pointer, like a shortcut or a symbolic link, inside Simran's file directory 2. Pointer points to the shared record     5. Invitation: A notification is sent to Simran. She clicks "Accept" Simran seeing the Folder 1. No Data Duplication: When Simran accepts, we don't copy all of Prakhar's files to her account     2. Instant Appearance 1. The next time Simran's device syncs, it fetches her file list 2. Metadata Service sees the pointer and seamlessly includes the contents of "Project Alpha" 3. The folder appears instantly on her device, with zero file data downloaded yet 🤔 over to you, what are benefits of "mount point" approach? Let me know in the comments! 👇 📣 Join 7-day email course to effectively optimize 60-minute system design interview - https://lnkd.in/gDBzCnE3 

48

16 Comments

The number one reason candidates fail system design interviews isn't technical knowledge. It's time blindness. After years of conducting HLD and LLD rounds, here's a pattern I keep seeing: ✓ The candidate knows the concepts ✓ The design direction is solid ✓ They're clearly technically capable ...but the interview ends incomplete. They spend too much time explaining every thought in detail, without watching the clock. And suddenly, time's up. What gets lost: → Key tradeoffs never get discussed → No runway to recover from early mistakes → No time to optimize or iterate → The hiring signals I need stay hidden Time is part of the evaluation. Not because we want you to rush, but because real engineering is solving problems under constraints. A simple framework that helps: Requirements + estimation (first 5 mins) High-level design (next 10 mins) Deep dive + tradeoffs (bulk of the time) Buffer for iteration (last 10 mins) Even if your design isn't perfect, this ensures you cover what actually matters. My advice: → Talk in checkpoints, not monologues → Ask: "Should I go deeper here or move on?" → Leave buffer at the end — that's where strong engineers stand out Your architecture might be brilliant. But if I can't see it, I can't hire you for it. If you're preparing for system design interviews: practice with a timer, not just a whiteboard. #SystemDesign #TechInterviews #SoftwareEngineering #HLD #LLD

21

Here’s exactly how I would crack a $150K+ SWE job at Microsoft in 6 months. (A real strategy my client used to land interviews at Microsoft, Meta, and Stripe) Too many engineers prepare hard to crack MAANG. But they lack a solid strategy. Here’s the exact roadmap I'll follow if I wanted to land a SWE job at Microsoft. Step 1: Resume + Role Clarity → Reverse-engineer the JD Study at least 10+ Microsoft SWE job listings. Highlight recurring keywords, must-haves, and preferred tools. → Rewrite your resume like a product pitch Show measurable impact: Good: “Improved load time by 43%” Bad: “Worked on performance optimization.” → Make it keyword-optimized for ATS without sounding robotic. Step 2: Master DSA the Microsoft Way → Focus on patterns, not problems Microsoft LOVES: Sliding window Trees (esp. DFS/BFS) Graphs Dynamic programming → Suggested Platforms: Leetcode (Microsoft tag), Neetcode(dot)io roadmap, Grokking series on Educative → 2 problems/day + 1 mock interview/week = compounding prep Step 3: System Design (yes, even for junior roles) → Start with High-Level Design (HLD): Learn how to design APIs, caching, rate limiting, and DB scaling. → Build a project where you actually implement what you learn. Step 4: Microsoft-Specific Behavioral Prep → Microsoft uses structured behavioral interviews Focus on “3As” framework: Action → Approach → Aftermath → Use real projects to show: Collaboration Adaptability Customer focus Engineering rigor → Prep 8–10 STAR stories mapped to their values Step 5: Mock + Real-World Practice → Do 4–5 peer or mentor-led mock interviews (especially for behavioral + design) → Record yourself. Watch for filler words, unstructured answers, lack of metrics. → Apply for 5 roles/week—Microsoft + similar-sized companies (to get into interview flow) Step 6: Apply Strategically + Use Referrals → Connect with 3–5 engineers/recruiters/week on LinkedIn. Don’t ask for a referral right away - engage first. → Reach out using tailored messages like: “Hi [Name], I’ve been preparing for an SWE role at Microsoft. Your journey from [X] to [Microsoft] really stood out. If you're open, I’d love to learn more about your experience.” → Submit applications using referrals whenever possible + 1-click apply where relevant The client who followed this playbook now works at Microsoft Azure and had 3 competing offers before accepting. It’s not about doing everything. It’s about doing the right things in the right order. Give yourself 6 months and follow this roadmap to make it a reality. Share this with someone who dreams of working at Microsoft. P.S. Follow me if you are a job seeker in the U.S. I share practical advice that gets you land $150k+ roles in top companies.

97

SDE Series#2.1 - The Traffic Controller of the Digital Highway:- How Load Balancers Keep the Internet from Having a Meltdown:- Setting the Stage: When Success Becomes a Problem Imagine you've just opened the hottest restaurant in town. Word spreads, reviews are glowing, and suddenly you've got a line of hungry customers stretching around the block. Great problem to have, right? Except now you're facing a new challenge: your single kitchen can't handle the tsunami of orders, your one chef is having a breakdown, and customers are getting hungry waiting for their food. This is exactly what happens to successful websites and applications. One day you're happily serving a few hundred users with a single server, and the next day you're trending on social media with millions of people trying to access your platform simultaneously. Without proper preparation, your server becomes that overwhelmed chef, and your users become those frustrated customers abandoning their digital shopping carts. Enter the Load Balancer which is your system's equivalent of hiring multiple chefs, opening several kitchen stations, and having a master coordinator who intelligently directs orders to whoever can handle them best at any given moment. LB Magic:- At its core, a load balancer is like having the world's smartest bouncer at the entrance of your digital nightclub. But instead of checking IDs and limiting entry, this bouncer is performing complex calculations in microseconds, deciding which of your backend servers should handle each incoming request. Think of it as a super-intelligent traffic dispatcher sitting at a busy intersection. When a request (car) approaches, the load balancer quickly assesses the current traffic on each available route (server) and directs the request down the path that'll get it to its destination fastest and most efficiently. Modern load balancers are like chess grandmasters, thinking several moves ahead and making decisions based on dozens of variables simultaneously. The System Design Engineer's Love Affair:- From a system design perspective, load balancers are absolutely critical for several reasons: Scalability: Let you scale horizontally by adding more servers instead of trying to build one impossibly powerful machine. Reliability: Distributing load across multiple servers, they eliminate single points of failure. If one server crashes, the others keep serving traffic while you fix the problem. Performance: Optimize resource utilization and reduce response times by ensuring no server is overwhelmed while others sit idle. Flexibility: Enable blue-green deployments, canary releases, and A/B testing by intelligently routing traffic between different versions of your application. Cost Efficiency: Maximize the value of your hardware investment by ensuring all servers are contributing to serving traffic. Let us see in 2.2 about many Faces of Load Balancing, Layer-4, Layer-7 and future of auto scaling.

14

1 Comment

Amazon puts over 50 LPA+ on the table for the SDE II role in India. Imagine you are interviewing for SDE-II role @ Amazon and in your system design round, the interviewer asks: "When I pause a movie on my phone and later open it on my TV, Netflix/Prime Video starts from the exact second I left. How would you design a system so a user can always resume from where they stopped, across all their devices?" Btw, if you’re preparing for system design/coding interviews, check out our mock interview tool. You can use it for free here: https://lnkd.in/gpCn7t2T [1] What a naive design would do Idea: Store progress only on the device. Flow - The player keeps the current timestamp in local storage. - When you reopen the app on the same device, it reads that value and seeks to that point. Why this breaks down? - You switch from mobile to TV and the TV has no idea where you stopped. - If you uninstall the app or clear data, progress is gone. - There is no single source of truth when you have many devices. Just local storage is not enough for a company like Amazon or Netflix. [2] What real systems do: server-side progress service Idea: Keep playback state on the server, and let every device sync to it. Core pieces - A "watch progress" service with an API like  POST /progress and GET /progress. - A table or key value store keyed by user_id + profile_id + title_id (+ episode_id). - Fields like position_seconds, duration_seconds, device_id, updated_at, status (in_progress, finished). What happens while you watch - The video player sends progress updates every N seconds or on key events  (play, pause, seek, stop, app background). - These are small API calls that update the row for that title. - If position crosses a threshold like 90 percent, the backend can mark the episode as "watched" and maybe reset resume point to 0. What happens when you open the app on another device? - The app calls GET /progress for the current title when you land on the details page or hit play. - The server returns the last known position. - The player seeks to that timestamp and starts from there, often with a "Resume from 37:12" prompt. Extra details you can add - Store a small history, not only one row, in case of bugs or rolling back state. - Use write behind or batching so heartbeats do not overload the backend. - Use TTL or cleanup jobs to remove very old partial watches. [3] Handling tricky cases Multiple devices at once - Two devices might send updates at the same time. - The service should keep the latest updated_at, or prefer the active device id. Offline viewing - For downloads, the device tracks progress locally while offline. - When it reconnects, it pushes a final progress event that updates the server. Privacy and size - Progress data is small but grows with millions of users. - A key value store or a simple sharded relational table is usually enough, since the access pattern is "get by key, update by key".

219

15 Comments

🚀 If you’re an SDE1 in #FAANG / #BigTech, here are the Top 5 things you should do to set yourself up for a successful career 👇 Most new engineers think their job is to “just write code.” But the SDE1s who grow the fastest — the ones who become SDE2/Senior early — do a few things differently. Here’s what I wish every new engineer knew in their first year: 1️⃣ Pair with as many engineers as you can As a new SDE1, you’ll usually work closely with a stronger engineer — use that time well. Learn by watching. Ask why they make the decisions they do. These relationships become your informal mentors and your accelerators. 2️⃣ Don’t be afraid to ask questions Your first year is the only time no one expects you to know everything. Use that leverage. Ask the “obvious” questions. Ask the deep ones. The fastest-growing SDE1s ask early → avoid rework → ship faster. 3️⃣ Align with your manager on expectations In Big Tech, misalignment slows growth more than lack of skill. Ask your manager: 🗓️ “What does success look like in 3 months?” 🗓️ “What should I be doing by month 6?” 🗓️ “Where should I be by end of year 1?” When you both agree on the path, everything gets easier. 4️⃣ Learn your team’s pain points — and offer to help Every team has broken pieces: ⚙️ CI/CD issues 🧪 Flaky tests 📉 Missing observability 📅 Weak planning or estimation Don’t wait for permission — pick one problem and propose a fix. Nothing builds trust faster than initiative. 5️⃣ Get your hands dirty with on-call & production issues You learn more from one real incident than from 10 clean deployments. Understanding systems in pain makes you a better engineer when building new ones. SDE1 isn’t just about writing code — it’s about learning the system, the culture, the people, and the craft. If you get these foundations right, every level after becomes easier. 👉 SDEs — what do you think made the biggest difference in your first year?

40

1 Comment

A candidate interviewing for SSE @ Google was asked to break down the design of Google Drive. Another candidate who was interviewing for the role of SDE-III @ Amazon, was asked another with a file upload system question. I’ve faced these too. System design rounds love “simple” file upload questions until you add one layer of complexity: – Add virus scanning? Whole new security headache. –  Add multi-region storage? Now you’re fighting replication and consistency. –  Add instant previews or image compression? Welcome to async pipelines and job queues. Here’s my personal checklist of 15 things you must get right when building file upload systems: 1. Never upload directly to your backend → Use presigned URLs so files go straight to S3, GCS, or your object storage, offloading bandwidth and freeing up backend resources. 2. Validate file type by content, not extension → Don't trust “.jpg” or “.pdf”, read the file’s magic bytes or headers to catch disguised executables or corrupted files. 3. Set strict file size limits (early) → Prevent memory blowups, denial of service, and accidental 50GB “cat video” uploads. 4. Multipart/chunked uploads for large files → Upload big files in chunks, so you can retry failed pieces, resume partial uploads, and never lose user progress. 5. Resumable uploads matter → User’s WiFi dies? Don’t make them start from scratch. Store upload progress, support resume tokens. 6. Async virus scanning before “marking ready” → Queue the scan; don’t let user-access or public-sharing happen until the result is clean. 7. Never trust user-supplied metadata → Recompute MIME types, image dimensions, video duration, etc., server-side, attackers will fake everything. 8. Expire unused presigned URLs fast → Every upload/download link should expire in minutes, not days. Stops replay attacks and stale-link leaks. 9. Background post-processing → Thumbnails, transcoding, compression, indexing, all should be async jobs, not blocking the upload. 10. Signed download URLs only  → Never expose raw S3 or GCS paths. Every download link should be time-bound and permission-checked. 11. Enforce per-user and per-IP rate limits → Throttle abusive clients, prevent brute force, and stop sudden spikes from melting your backend. 12. Encrypt files at rest (and in transit)  → Use server-side encryption (SSE) on S3 or GCS, plus HTTPS/TLS for every file transfer. 13. Version every upload → Store new files with unique IDs or version suffixes, never overwrite by default. Enables “undo” and rollback, and prevents race conditions. 14. Log every upload and access → Audit logs for every file action: who uploaded, who accessed, when, and from where. Critical for debugging and compliance. 15. Handle storage failures and edge cases gracefully → What happens if S3 times out? What if storage quota is exceeded? Handle partial failures, show clear errors, and keep users in the loop. Feel free to reach out to me: https://lnkd.in/guttEuU7

2,081

73 Comments

Groww’s 1,400+ employees have created ₹44 crore of value each at IPO market cap. 🔥 2× more leverage per employee than any other listed Indian internet company. Most people talk about network effects, margins, growth, CAC, operating leverage… But one under-discussed indicator of platform strength is value created per employee. 🚀 Groww is running one of the leanest teams among large venture-backed IPO scaleups — and that’s the part that should interest founders, operators, and investors the most. Fewer employees. Massive output. Maximum leverage. This is the real internet efficiency story — not user counts or vanity GMV. https://lnkd.in/gXp6GJ5F

110

2 Comments