Layrs

When I joined Flipkart as a backend dev, I’d never seen batch jobs that processed millions of records in one go. It was mind-boggling and honestly intimidating at first. When I broke a pub/sub pipeline for the first time at Flipkart, I realized how humbling the scale really is and how much just one mistake can cost you. When I joined Google, something similar happened. I went from building REST APIs to learning what true “global” reliability and compliance mean. Google’s scale was even bigger than Flipkart, and again I felt out of depth. When I started Layrs after quitting my 9-5 at Google, I was out of my depth again. But this time I had no manager, no legacy code; it was just my whiteboard, me in my flat with my co-founder, and we were juggling a thousand unknowns. I had to learn AI pipelines from scratch, learned how to build a scalable frontend, manage payments, and make an interactive tool that benefited users. If there’s one thing I have personally realized in the last 5-6 years of my life is that: You’re never 100% ready for the next step. You’re always out of your depth somewhere, whether it’s a startup or FAANG. But you grow into it. You learn to live with it and become a better engineer. Don’t let “I haven’t done this before” stop you from doing it anyway. You’ll learn more in the arena than you ever will from the stands.

Out of the 300,000,000 users on Netflix, anyone can resume from exactly the point they paused a movie/series, and they even see a feed of all the movies they left midway. People love this feature because you don’t have to rewatch the whole movie or series from the beginning to find where you stopped last time. On most OTT platforms, such as Netflix, you have the feature of watch history. But how exactly does this feature work, and how do you implement it in a system like Netflix’s?” Let me break it down for you (this is actually a topic I was discussing during a mock interview just recently with an engineer who’s part of the Layrs community) 1. The Client Tracks and Reports Progress – As you watch a show or movie, your app keeps a running count of how many seconds or minutes you’ve completed. – This information isn’t just for your phone, it needs to be sent back to Netflix, so you can pick up where you left off on any device. – But: If every second of progress is sent as a separate request, Netflix would be flooded with traffic from millions of users. So, the app typically sends updates every few seconds or at logical milestones (e.g., pause, stop, seek, close). 2. Why Direct Database Writes Don’t Scale –The most basic approach would be: every update goes straight to the main user database. –This becomes a disaster at Netflix scale, millions of users watching, rewinding, or skipping forward, all day. – Constant real-time writes would crush the database, causing delays for users and risking outages. 3. Introducing Asynchronous Messaging (Decoupling Write Paths) – To keep the user experience smooth, Netflix doesn’t write progress directly to the database in real time. – Instead, the app sends progress updates as messages to a message queue (like Kafka or AWS Kinesis). – The queue immediately “accepts” the update, so the app can instantly acknowledge the user, no waiting around. 4. Batch Processing in the Background –Backend workers process these messages from the queue in batches or near real-time, updating the database with each user’s latest watch position. – Batching reduces write pressure on the database and improves efficiency. – Even if a server fails, the queue holds the messages safely until processed. Ran out of space, continued in commens ↓ – P.S: If you’re learning system design, let me make it easy and fun for you just like Leetcode, all you to have to do is sign up on Layrs (layrs.me). Layrs gives you the practice you need to crack interviews, it has: - 60+ problems - Interactive canvas and constraints - Proper feedback right after you build an answer - Sequential and easy-to-hard level learning process

Multithreading ≠ Concurrency Multithreading ≠ Multiprocessing Multithreading ≠ Async Programming One of the most painful confusions in system design is mixing up these terms: Multi-threading, Multi-processing, Concurrency, Asynchronous Programming Let me clear it up for you once and for all...  [1] Multi-threading – Multi-threading is a way to achieve concurrency by running multiple threads within the same process. – Multi-threading is not the same as multi-processing (it shares memory space, processes do not). –  Multi-threading is not asynchronous programming (threads may still block, async code does not). – example: Your web browser can download files (one thread), render the page (second thread), and listen for your clicks (third thread) all in the same app, sharing the same memory.  [2] Multi-processing – Multi-processing is running multiple independent processes, each with its own memory space and resources. – Multi-processing is not multi-threading (processes do not share memory, threads do). –  Multi-processing is not asynchronous programming (separate processes, not async callbacks). – example: When you open 5 tabs in VS Code, each tab might be a separate process (with its own memory), so if one crashes, the others keep running.  [3] Concurrency –  Concurrency is about handling multiple tasks at once, but *not necessarily* doing them simultaneously, just managing their progress together. – Concurrency is not the same as parallelism (parallelism = truly simultaneous, concurrency = juggling tasks, might just be switching between them). – Concurrency is an umbrella term, multi-threading, multi-processing, and async programming are all techniques to achieve concurrency. –  Concurrency is not a specific technology, but a design approach. – example: A restaurant chef handles orders for 10 tables, switching between tasks (chopping, frying, plating) so all meals finish around the same time, but he’s not physically cooking 10 dishes at once.  [4] Asynchronous Programming –  Asynchronous programming is a way to handle tasks that might wait (like network calls) without blocking the main thread. –  Asynchronous programming is not multi-threading (can run in a single thread, no context-switching, relies on events/callbacks/promises). –  Asynchronous programming is not multi-processing (doesn’t use multiple processes). –  Asynchronous programming is a type of concurrency, it lets your app do other work while waiting for a slow operation to finish. – example: You order a pizza (async call), keep watching TV or chatting (main thread not blocked), and get a notification when the pizza arrives (callback). — Btw, if you’re learning system design, do check my platform: Layrs (layrs.me). Think of it like Leetcode but for system design. You get: - 60+ problems - Proper feedback right after you build an answer - Sequential and easy-to-hard level learning process Join our discord: https://lnkd.in/g9wGRadq

Imagine you’re in a system design interview at Amazon. You’re whiteboarding the architecture for something massive, let’s say:  “Design Amazon’s Order Processing System for Prime Day.” The interviewer suddenly asks: You’ve designed this for 99% uptime. Why are you not designing for 99.999% uptime? Do you know what happens if customers can’t place orders for three days in a year at Amazon? Now you’re on the spot. If you’ve never read about availability, it just looks like you can round off those nines after the decimal, call it 99%, and move on. But it doesn’t work like that. Every single ‘9’ after the decimal is a mix of tradeoffs and complexity. Here’s what you’re saying when you choose your target uptime: – 99% uptime = ~3 days, 15 hours of downtime per year – 99.9% uptime = ~8 hours, 45 minutes per year – 99.99% uptime = ~52 minutes per year – 99.999% uptime (“Five 9s”) = just 5 minutes, 15 seconds per year   (~26 seconds/month, ~6 seconds/week) Every ‘9’ you add is another layer.  Failover, redundancy, instant detection, zero-downtime migrations, and global disaster recovery, all of these elements will be added to it. So, why can’t every company just aim for Five 9s? Because at that level, everything gets brutal: – You need to split data across the globe and still keep it consistent. – You have to spot failures and reroute in milliseconds. – You’re architecting for world wars, not just traffic spikes. Enter the CAP theorem: – Consistency: Users see the same data, everywhere, all the time. – Availability: The system never, ever goes down. – Partition tolerance: It survives network splits and chaos. You don’t get all three. Push for that extra ‘9’ in uptime, and you WILL have to give up consistency somewhere, or spend millions building cross-region failover that barely holds together under chaos. Every ‘9’ you chase is a multiplier of cost, engineering stress, and sleepless nights. — P.S: If you understand the concept of availability with a simulation and get real-time feedback on your system design skills for free, check out Layrs (layrs.me) Think of it like Leetcode but for system design. Layrs gives you the practice you need to crack interviews, it has:  - 60+ problems - Interactive canvas and constraints - Proper feedback right after you build an answer - Sequential and easy-to-hard level learning process Join our discord: https://lnkd.in/g9wGRadq

I invested 4+ hours and collected 70+ system design problems that have helped people I know (juniors and community members) clear interviews at Google, Salesforce, Flipkart, Uber, Microsoft, and Amazon… I would say these are 20% of the common problems based on essential topics that come in interviews 80% of the time. ➥ Core Infrastructure & Storage: 1. Design a SQL-backed KV Store 2. Design a Superfast KV Store 3. Design a Faster Superfast KV Store 4. Design S3 (Object Storage) 5. Design a Distributed Cache 6. Design a Distributed File System 7. Design a Wide Column Database 8. Design a Key Value Store 9. Design a Log Collection and Analysis System 10. Design a Domain Name System Note: You don’t need to grind through all 75 problems or memorize every pattern here. The idea is simple: Explore and learn how these systems work, so you can build and reason about real-life products. If you want to see how these problems play out in real-world scenarios, you can try them on our system design learning platform: layrs.me. Join our discord: https://lnkd.in/g9wGRadq You’ll get to interact with and simulate real system design problems. whether you’re building for 100 people or a million users. I genuinely believe there’s a better way to learn system design, by building, breaking, and experimenting. Check it out if you want to learn system design in a structured manner and have fun (and see how top companies think and judge you with these problems) ➥ Realtime & Event-Driven Systems: 11. Design Online/Offline Indicator 12. Design a Realtime Database 13. Design Synchronized Queue Consumers 14. Design Flash Sale 15. Design Realtime Claps 16. Design a Distributed Messaging System 17. Design a Push Notification Service 18. Design an Event Lifecycle Management System 19. Design a Scheduled Digital Transaction System 20. Design a Real Time Stock Trading Platform 21. Design a Distributed Tracing System ➥ User-Facing Apps & Social Systems: 22. Design a Blogging Platform 23. Design OnePic (Photo App) 24. Design Photo Tagging 25. Design HashTag Service 26. Design User Affinity 27. Design Yelp or Nearby Friends 28. Design Facebook’s Newsfeed 29. Design a Graph Search Function for a Social Network 30. Design a Chatbot Framework 31. Design an Auction System 32. Design a Smart Home System ➥ Search, Messaging & Delivery Systems: 33. Design a Word Dictionary 34. Design Text-Based Search Engine 35. Design SQL-backed Message Broker 36. Design a Distributed Task Scheduler 37. Design a service to show Recent Searches 38. Design a Web Crawler 39. Design a Web Crawler That Will Crawl Wikipedia 40. Design Google Search 41. Design Google Doc 42. Design an Automated Trading Platform Continued in Comments…

An offer of more than 60LPA CTC, that’s what Salesforce puts on the table for the MTS-II role, and I’m glad to tell you that one person from our Layrs (layrs.me) community has successfully cracked this role and joined Salesforce! Yesterday, I posted about how the community was coming alive, and this news couldn’t have come at a better time. And I am so glad that Layrs helped him with his system design preparation on this journey. This is how the process looks behind the scenes: The MTS-II (Member of Technical Staff-II) role is a significant step up from the entry-level MTS role. MTS is heavily focused on DSA and problem-solving. MTS-II expects in-depth system design, architecture, and domain knowledge on top of solid coding skills. The interview loop is of 4 rounds: 1️⃣ System Design + Architecture / Data Concepts – High-level system design: open-ended problems (e.g., design BookMyShow, scalable notification system, or payment gateway). – Expect to talk through API contracts, key entities, relationships, scaling, and trade-offs. – Deep questions on database choices, data modeling, partitioning/sharding, and ensuring reliability. – Prepare to explain why you’d pick one architecture over another, cover edge cases, possible failures, and improvements. 2️⃣ LeetCode-Style DSA Round – Pure coding round, usually 1–2 problems. – Recently asked questions include: + Valid word count from a character array (use backtracking/trie/hashmap as needed). + Snake & Ladder: Minimum dice throws to reach end (graph/BFS approach). – You’re expected to explain your approach, dry-run your code, discuss time/space complexity, and answer follow-ups on optimizations. 3️⃣ Frontend Development – Covers JavaScript/TypeScript basics, React/Vue/Angular, or any frontend stack relevant to the team. – System design for frontend: component architecture, state management, performance, API integration. 4️⃣ Domain / Architecture Knowledge – Deeper dive into your past experience, design choices, and domain expertise. – Questions may include: + Design an existing system you’ve worked on. + Discuss trade-offs and technical decisions you made. + Explain architecture patterns (microservices, event-driven, etc.) – Expect behavioral scenarios too: handling failure, cross-team collaboration, learning from mistakes. If you’ve got this loop coming up: Prepare broadly, but also go deep on your own projects. Focus on explaining your thought process, not just the “right answer.” Good luck! — P.S: When it comes to getting hands-down practice, you can rely on Layrs, it’s a system design learning platform we have created. Think of it like Leetcode but for system design. It gives you the practice you need to crack interviews. It has:  - 50+ problems - Interactive canvas and constraints - Proper feedback right after you build an answer - Sequential and easy-to-hard level learning process Join our discord: https://lnkd.in/g9wGRadq

I quit my 9-5 at Google to work 24/7 on my idea, along with Gaurav Pal. A couple of months ago, we started Layrs (layrs.me) with a simple idea: Build a practical and interactive system design learning platform, along with a community. I will not lie, at first, it was quiet. Too quiet.. It was just me and Gaurav sharing product updates and the roadmap for the features that will be coming along. Fast-forward a few weeks… – People are pairing up for mock interviews. – Members are suggesting ideas, running polls, shaping what we build. – Small initiatives have started that make it feel less like “our product” and more like our shared space. Watching this shift from updates to true community has been humbling and rewarding. I guess, communities don’t come alive overnight, and they shouldn’t..They should grow slowly, one interaction, one conversation, one bit of initiative at a time. Over the past few weeks, I’ve been lucky to see that happen inside our Layrs Discord. And honestly, it’s why we’re even more motivated and in high spirits. A product is just code and features. But a community with people supporting each other, building together, and making things better bit by bit to back it up, makes the whole experience so much better. We’re also working on something bigger behind the scenes. 👀 When it’s ready, Layrs community members will get first access. If you’re interested in system design or have just started learning and want to learn by building, or just want to be part of a community learning side by side. You’re invited: https://lnkd.in/g9wGRadq (Can’t wait to see what we build together.)

A Junior of mine has just made the switch from Samsung Electronics (12 LPA) to Google (35+ LPA) in the current job market. This is his entire interview experience with Google that he shared with me. ➱ Background – Education: B.Tech, CSE, Tier-3 College – Experience: 1.5+ years at Samsung R&D – Previous CTC: 12.5 LPA ➱ Google Offer Details (Bengaluru | L3) – Base: INR 23.1 LPA – Joining Bonus: 1.47 L – Relocation Bonus: 4 L – Variable Bonus: ~3.3 L (15% of base) – Stock Grant: USD 57K (vesting: 38% / 32% / 20% / 10% over 4 years) – Total Comp (Year 1): ~50.7 LPA ➱ Interview Process 1. Resume Shortlist – Initial recruiter outreach (LinkedIn + phone) – Basic profile screening: role, coding profiles, past projects, timeline 2. Phone Screen (DSA, 45 min) – Questions similar to: + Longest Consecutive Sequence + Painter's Partition Problem (variation) 3. Onsite Rounds (4 Technical, 1 Googleyness, 45 min each) ○ Round 1: Dynamic Programming / Tree-based Problems + Coding problems similar to:    • House Robber III (Stickler Thief)    • Dungeon Game + Focus:    • Designing optimal DP/state transitions    • Handling tree recursion and edge cases    • Discussing alternative solutions and time/space trade-offs ○ Round 2: Subsets, Partitions & Array Manipulation + Coding problems similar to:    • Partition Equal Subset Sum    • Partition Array into Two Arrays to Minimize Sum Difference + Focus:    • Breaking down problems into subproblems    • Backtracking, bitmasking, or advanced DP as needed    • Walking through test cases and edge scenarios ○  Round 3: Advanced Scenarios / Graph & Optimization + Coding problems similar to:    • Maximum Employees to Be Invited to a Meeting    • Loss Interval Optimization + Focus:    • Building custom algorithms from scratch    • Working with graphs, cycles, and optimal selection    • Dealing with constraints, handling tricky inputs, and thinking out loud ○Round 4: Complex Data Structures & Performance + Coding problem similar to:    • Count of Smaller Numbers After Self + Focus:    • Efficient use of segment trees/BSTs/binary indexed trees    • Writing code that scales for large inputs    • Explaining logic, handling follow-ups, and discussing optimization Round 5 (Googleyness): Behavioral/Culture Fit +Standard behavioral questions (teamwork, conflict resolution, prioritization, motivation for Google, etc.) Result: Offer received: Google SWE II (L3), Bengaluru | 1st year comp: ~50.7 LPA — P.S: I am sharing this because I took mock interviews to help him prepare. Also, I am proud to tell you that 2 of our community members who were users of Layrs got placed at: – Salesforce SDE 2 – DP-World SDE 2 It’s been a few months after I’ve quit my 9-5 at Google, and seeing results like this just gives me more power. Btw, if you haven’t tried Layrs yet, so sign up, it’s Leetcode but for system design: layrs.me Join our discord: https://lnkd.in/g9wGRadq

I’ve conducted 30+ interviews at Google, Flipkart, and honestly, some of my best hires have been engineers who came from places with no support, tier-3/4 cities, or non-prestigious colleges, but had undeniable skill and hunger. No two stories were ever the same. It’s true that life is unfair and nothing is handed to you. It’s true that some people will always have more privilege than you. But the only way to break through those barriers is to go all in on your goals and back it up with relentless consistency. I’ve seen people come from backgrounds where nobody even expected them to get into tech. But what they had was hunger, ownership, and a drive to keep learning. I’ve watched folks join with zero experience in teamwork.  People who started off lost, but never lost their curiosity. They asked questions, made mistakes, and delivered anyway. Within months, they were: – Shipping features – Fixing broken things nobody else would touch – Communicating with stakeholders like pros – Taking on challenges well above their level They just showed up, figured it out, and grew with every step. That’s why I believe you don’t need a perfect background to break into tech. You need ownership. You need curiosity. You need the willingness to keep learning, even when nobody’s watching. Most people count themself out before they even start because of some reason in their head, I say, that’s a stupid way of holding yourself back. If I thought that way, I wouldn’t be here writing this post. You might not have head start. But just refuse to give up. Things will fall in place. 

Redis is open source. Nginx is open source. PostgreSQL, Docker, Kubernetes, RabbitMQ, MongoDB, Prometheus, Grafana - all open and accessible. GitHub Actions even has a free tier. You don’t need a certificate to design real-world systems. The docs are public. The code is one git clone away. – Set up a load balancer with Nginx or HAProxy. – Build a pub/sub queue with RabbitMQ or Kafka. – Store logs and metrics with Prometheus, Grafana, or ELK. – Architect a fault-tolerant API with PostgreSQL, Redis, and stateless containers. – Automate CI/CD with GitHub Actions. – Simulate failures, recover, and deploy again. It doesn’t matter if you learned from YouTube, a paid bootcamp, or trial and error. What matters is whether you can break a system, find the root cause, and ship the fix. Don’t wait for the “perfect” course or the “right” time. Pick a system design pattern, open the docs, and start building. That’s how you actually learn. Everything else is just delay. P.S. I quit my job at Google 2 months ago to build Layrs (layrs.me) - a platform where you can practice system design hands-on. Since then, 1000s of engineers have already started learning and improving. I’d love for you to give it a try. Join our discord: https://lnkd.in/g9wGRadq