Harsh Ranjan

You are in a system design interview at Amazon for an SDE-3 role and the interviewer has given you the question to Design Netflix. He then asks a follow up to you: How does Netflix knows when to show: Are you still watching? Is it just time-based? If it were time-based, you would see it every time. So what is actually going on under the hood? Both look like a simple pop-up. Underneath, it is a mix of product thinking, client logic, and backend events. 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] Start from the product goals The feature is not only about nagging people. - Save bandwidth and CDN cost if the viewer has slept or walked away - Avoid autoplaying potentially sensitive content in an empty room - Protect kids if parents start a show and leave the TV on - Do all this without annoying active binge watchers So the design must answer one question: "When is the user probably not here any more" [2] Naive design - pure timer Simplest idea: - If playback has been running for 2 hours, show Are you still watching - If user clicks "Yes", reset the timer Why this is weak: - Someone can binge 5 episodes in a row and gets interrupted in the middle of an intense scene - Someone can start a show, walk away after 5 minutes, and the platform will keep streaming for the next 2 hours - It ignores how many episodes were auto played, device type, time of day, user habits  [3] Realistic design - session and engagement signals Think in terms of a "watch session" and "engagement events". Signals the client can track: - Play, pause, seek, volume change - Episode finished and next episode auto started - Remote or keyboard input, UI navigation - Screen on or off events from the device - For mobiles: app background or locked state A common heuristic could be: - Count how many episodes have auto played without any user interaction - Track how long it has been since the last button press or navigation - Only trigger the prompt when both are high enough Example rule: - If 3 episodes in a row have auto played - And there has been no interaction for 45 minutes - Then, before starting episode 4, show Are you still watching This feels much smarter: - Active viewers who pause, skip intro, change volume keep resetting the "engagement clock" - Sleeping viewers do not touch anything, so the next episode is blocked by the prompt  [4] Client heavy vs server heavy design You can talk about two design choices. Client first: - All logic runs inside the app on TV, mobile, or web - Client keeps an in memory session model and decides when to show the popup - It still sends telemetry events to backend for analytics and future tuning Pros: - Works even with flaky network - Highly responsive, no extra server round trip Cons: - Logic must be implemented and updated across many platforms - Harder to quickly roll out rule changes Continued ↓

184

12 Comments

If you want to perform better in system design interviews, spend time understanding these trade-offs, and your interviews will go 10x better. Because when you're building systems, every decision is a trade-off. This is where most candidates fail, they can’t explain why they made a choice. Don’t let that be you. 1. Core Concepts The fundamentals you can’t skip. – Scalability vs Performance: Handle more work or make the system faster — rarely both at the same time. – Latency vs Throughput: Quick responses vs high volume processing; real-time vs batch-focused needs. – SQL vs NoSQL Databases: Structured, reliable queries vs flexible, scalable, schema-less data storage. – Stateful vs Stateless Architecture: Systems that remember session context vs fully independent requests. 2. Foundational Trade-offs Principles that shape every architecture decision. – Vertical vs Horizontal Scaling: Upgrade one server or add more servers for distributed growth. – Consistency vs Availability (CAP Theorem): Always accurate data vs systems that never go down. – Strong vs Eventual Consistency: Immediate accuracy vs short delays for better performance and uptime. – Normalization vs Denormalization: Clean, duplicate-free storage vs faster reads with some redundancy. 3. System Optimization Patterns for performance and reliability. – Read-Through vs Write-Through Cache: Cache when requested vs write to cache and database simultaneously. – Synchronous vs Asynchronous Processing: Wait for each task vs process tasks in the background. – Batch vs Stream Processing: Process data in bulk vs handle it in real time as it arrives. – Long Polling vs WebSockets: Periodically request updates vs keep a live, two-way connection. 4. Advanced Architecture High-level decisions that define modern systems. – Monolithic vs Microservices Architecture: One unified codebase vs many smaller, independent services. – TCP vs UDP: Reliable, ordered delivery vs faster, less reliable transmission. – REST vs GraphQL: Fixed endpoints with standard responses vs flexible, efficient queries for exactly what you need. If you can talk through these trade-offs with clarity, you’ll stand out in system design interviews. It’s not just about what you build, t’s about why you built it that way. Which of these trade-offs do you still struggle with? — P.S: If you’re trying to master system design, check out my platform, layrs.me. I quit my job at Google to change the way we learn system design. Layrs will help you build, understand, and learn how system design looks in real life. From understanding these trade-offs, you can see how constraints, components, and architecture all come together to power the biggest systems in the world. 

129

9 Comments

Imagine you just joined Google as an SWE. It’s your first week, and you’re overthinking everything. You’re surrounded by world-class engineers, new systems, and an overwhelming urge not to mess up. The pressure to prove yourself is real, and so is the anxiety…so what should you do? Over the years, I’ve moved across orgs, teams, and sometimes, entire companies. Here’s exactly what I did (and still do) to ramp up faster and enjoy the process without letting anxiety win → Don’t let yourself stay stuck. If you’re blocked for more than 30 minutes, ask for help. Share what you’ve tried, show initiative, and intent. → Read way more code than you’re assigned. Dive into related modules, historic PRs, and old design docs. The context you gain helps you spot patterns and avoid mistakes. → Ask about the story behind the system. Find out why things are built a certain way, what’s failed before, and what’s on the roadmap. Understanding the “why” beats memorizing the “what.” → Volunteer for unglamorous work. Take ownership of tests, docs, or nagging integration bugs. This is where you quietly learn the most and build your internal network. → Offer help before you’re an expert. Chime in when you see questions, review PRs, or share a script. Even small contributions get you noticed for the right reasons. → Connect with skip-levels and cross-team leads. Set up short intros to learn about the broader vision and team priorities. You’ll spot opportunities to add value beyond your immediate tasks. → Document what you learn as you go. Share notes, update READMEs, or post quick how-tos in team channels. Your future self and your teammates will thank you. → Shadow someone during incidents or launches. Sit in on debugging sessions or war rooms, even if you’re just observing. You’ll see how senior folks think, react, and communicate under pressure. → Keep a running list of “how did that break?” moments. Every time you see a system fail or a hotfix go live, dig in. Reverse-engineering past problems is the fastest way to understand the architecture. → Show up with curiosity and intent, every day. Don’t just tick off JIRA tickets. Look for the bigger picture. People notice when you genuinely want to learn and contribute, not just “do your job.” Some orgs assign mentors, some don’t. Either way, these habits put you in the driver’s seat. Ramping up is less about brilliance, more about consistent intent. And the ones who learn this early end up leading teams later.

709

51 Comments

Microsoft Just Made 100B Parameter LLMs Run on Your Laptop. Who Governs Them? BitNet breaks the GPU barrier. 1.58 bit quantization. 100 billion parameters on a single CPU. No cloud. No API costs. Local inference at human reading speed. This is a genuine breakthrough for accessibility. But accessibility without governance is liability. Running locally solves the infrastructure problem. It does not solve the governance problem. A 100B parameter model on your laptop can still hallucinate with confidence. It can still produce biased outputs. It can still make decisions with no audit trail. It can still violate constitutional bounds you never defined. Privacy from cloud providers is not the same as privacy from the model itself. Local execution means your data stays on your device. It does not mean the model operates within governance constraints. The question is not where the model runs. The question is whether the model can prove it operated within bounds. YIN-GATEWAY solves this. YIN-GATEWAY is a cryptographic control plane that sits between any LLM and its users. Cloud model, local model, quantized model, full precision model. The deployment changes. The governance requirement does not. Layer 2 Admissibility Gates reject non-compliant queries before execution. The model never sees requests that violate policy. Layer 3 Constitutional Bounds verify every output before it reaches users. If the output would violate governance constraints, it does not proceed. Layer 14 SENTINEL Verification runs independent binary checkpoint validation. Pass or fail. No partial compliance. Layer 15 Human Override requires cryptographic signatures before high-risk outputs proceed. Not a checkbox. A mathematical proof that a human authorized this specific action. BitNet gives you a 100B parameter model on your CPU. YIN-GATEWAY gives you cryptographic proof that the model operated within constitutional bounds, regardless of where it runs. The hardware revolution is here. The governance layer was already built. https://lnkd.in/eb2EdEwR 32 USPTO applications. 3,057 claims. Any model. One governance layer. Enforced behavior. #BitNet #YINMazariArchitecture #YINGATEWAY #AIGovernance #CryptographicCompliance #Microsoft #LocalAI #LLM #PrivacyPreserving #ResponsibleAI #EdgeAI #CPUInference #OpenSource

4

1 Comment

The first SDE-2 absolutely nailed the system design round. The question was: Design a live streaming system. The second SDE-2 was asked to Design Google Drive. He did well, spoke about trade-offs, but missed one important detail: chunking the file, especially for large uploads. Yet, the second engineer got the job. These are from real interviews I took around 4 months ago. You might ask: Why? Only one reason, the second one nailed the behavioral questions like a boss. The question was about working on a project with tight timelines. The first SDE-2 (subtly) blamed the external team’s API for delays, which led to tight project deadlines. The second one, on the other hand, shared a story about how he helped his manager prioritize requirements to navigate the crunch. That’s how important behavioral interviews are. Yet, 90% of SDEs leave them to luck. If everything else is equal: - DSA (both solved the coding problems), - LLD (designed with solid object-oriented principles), - HLD (covered all the P0 functional and non-functional requirements) then your behavioral answers become the deciding factor. Yes, the second engineer missed the file chunking detail. But it wasn’t a critical red flag. He covered all other parts well and crushed the behavioral round. As long as you're working with humans (no matter how many), you’ll be judged on your behavioral skills. Call them soft skills, leadership skills, whatever you like, but you should prepare them well in advance. You can start preparing for behavioural interviews right away, with these 5 MUST read behavioural interview posts I wrote. (tip: save this post for later, as it may take some time to complete all of them) [1] How to answer any behavioural interview question https://lnkd.in/gH3N8b5q [2] 4 step guide for behavioural interview preparation in 3 hours https://lnkd.in/gccxG3MP [3] How to create 10+ stories for your past projects https://lnkd.in/g4nv_jqU [4] How to answer a failure story? https://lnkd.in/gtN-Dfuv [5] 10 behavioural interview mistakes to avoid at all cost https://lnkd.in/gpupvYVs If you’re preparing for mid-senior SDE or EM roles and need dedicated help with behavioral interview prep, DM me COACH.

134

23 Comments

A lot of posts recently talking about the shift away from the physical act of writing code/syntax going around so I’ll weigh in with my personal experience. 2025 was a watershed moment for LLMs. With Claude Code it was finally “smart” enough for mass adoption. It now writes code better than most “programmers”. But here’s the important distinction. Engineering and Programming are not the same. As engineering leadership I see it every day. People who think writing code is their job, not requirment gathering, planning, designing and architecting systems, validating correctness, problem solving. People who have these skills, can make effective use of Claude. These are the successful early adopters and 10x engineers right now. Now here’s what that means for me personally. After a long time, I am enjoying being a software engineer again. There was a time I was deeply married to writing code (it was kind of the therapeutic part of software development for me). But the shift into people management, becoming a father, and other life commitments has slowly erroded any time I have to take on projects that require hours or continuous focus. Writing code became the moat around me inventing. That is no longer the case. LLMs have enabled me to enjoy software development again. I can work in more bite sized chunks that fit into my day. I can engineer solutions in idle time. I can invest in custom tooling quickly that would have been month long side quests before. I can dip into other development domains (backend, browser extensions, languages) that previously would have take months of learning to become effective. This is what it has meant to me, do you have any similar experiences?

40

40 Comments

Why does an E3 level SWE at Meta make only ~190k/year, while an E8 level engineer makes over ~$2M/year, even though both engineers are ICs and spend the same time at work? I have spent the last 5 years at Meta as an IC. I joined with a little over 15 years of experience, and I’ve worked with many solid engineers in this time. Here is how I think about that compensation jump. 1. Same hours, completely different “unit of work” An E3’s unit of work is usually a task or a ticket. An E8’s unit of work is a multi year problem for the company. E3: “Implement this service, fix this bug, write this feature.” E8: “How do we cut infra cost by 20 percent across this product” or “How do we make this platform safe to scale to 10x users.” One person is paid to execute. The other is paid to decide what is worth executing in the first place. 2. Radius of impact E3 usually impacts a file, a service, maybe a small team. E8 shapes whole orgs and product lines. If an E3 ships something great, the impact is great but local. If an E8 ships the right platform, hundreds of engineers become faster and the company saves or earns millions every year. Comp tracks the area of the circle you influence. 3. Risk and downside protection At junior levels, mistakes are usually contained and reversible. At senior staff levels, a bad call can burn tens of millions or damage the brand. E8s are paid for judgment under ambiguity. They decide which bets the company should not make, which migrations can wait, which “shiny idea” is going to kill reliability. You pay more to people whose good judgment protects you from very expensive failures.  4. They scale themselves This can happen in a few ways. 1. Delegation with ownership They define the shape of the problem, then hand large pieces to other senior and mid level engineers while keeping the bar and direction clear. 2. Knowledge that travels They write RFCs, public comments, FAQs, wikis, internal posts. One answer helps hundreds of people who will face the same issue next quarter. 3. Tools over heroics Instead of unblocking people manually all day, they build tools, libraries or guardrails so others can unblock themselves. One well designed tool can save thousands of engineering hours every year. This is what “scaling yourself” actually looks like. The company pays for that multiplier.  5. Ownership of the “uncomfortable problems” Junior engineers usually work inside a well defined box. E8s take ownership between the boxes. They pick up problems that:  Span many teams and no one really “owns”  Require aligning leaders who disagree  Have product, infra, legal and security angles at the same time Most people avoid those because they are messy, political and slow. Very senior ICs lean into them. That is where a lot of value sits. Continued ↓

201

15 Comments

Ruokai Yin, our summer intern from Yale to Microsoft Azure, worked with Xuan Zuo, @Sattwik Deb Mishra, Hokchhay T. and Preyas Shah and me. We published a paper based on his project: https://lnkd.in/eHuG3BSt Summary of paper: Finding optimal sharding is hard especially for large LLMs. A large number of devices have to be divided into TP, PP, EP dimensions. For TP, we have to decide the tensor dimension e.g. head, hidden size to shard for every op. Additionally, TP can be one-dimensional/two-dimensional etc. This makes for a large sharding space that is hard to cover exhaustively. SoTA methods use heuristics to select sharding e.g. GSPMD, Sequence Parallelism, Helix etc. There are significant time gaps, months or years, between the discovery of each of these methods. We want to fast-forward the process of discovery by 1) using a formal representation of the sharding space, and, 2) using reinforcement learning to search the sharding space.    This paper demonstrates that our method is 3.5x better than random search, and on par with hand-tuned heuristics when looking only at 1D sharding and without allowing sequence parallelism. We aim to extend the work to multi-dimensional sharding as well as sequence parallelism. Beyond that, we wish to combine the problem of sharding with fusion, tiling and collectives as well.

58

Why the Amazon Layoffs are a Wake-up Call for Every Engineer The era of "pattern-match engineering" is closing. Recent reports show Amazon cutting thousands of corporate roles as part of a deeper pivot toward AI-augmented productivity. This isn't just about cost-cutting; it's a fundamental shift in what the industry values. Any work that relies on applying matured designs to new cases by following a set pattern is now within the territory of AI. If your value is purely in the execution of these patterns, that value is rapidly depreciating. To remain non-replaceable, we must shift our focus: From Execution to Architecture: Don't just follow the pattern; design the system that leverages it. From Bandwidth to Innovation: Use AI to handle the repetitive "heavy lifting" so you can reclaim your time for new, high-value innovation. From Coder to System Shaper: The most valuable engineers today aren't just writing code; they are directing AI to produce results and solving the complex problems AI can't yet touch. The goal isn't to compete with AI—it's to leverage it to expand your own impact. In an industry that is "right-sizing" through technology, those who use AI as a force multiplier will be the ones who lead the next wave. https://lnkd.in/g2RHA4zr

57

2 Comments