Vinay Sharma

🔍 Found this while checking Amazon's frontend code: if (!csrfSafeMethod(arguments[0]) && isCartRequest(arguments[1])) { this.setRequestHeader("anti-csrftoken-a2z", csrf_token); } Looks simple. But does something important. The Problem: You're logged into Amazon. You visit another site. That site can secretly send requests to Amazon as you — because your browser automatically sends your login cookies. Result? Items added to your cart. Address changed. Without you clicking anything. This is called a CSRF (Cross-Site Request Forgery) attack. What's happening here? Amazon adds a secret token to every cart request. ✅ Token generated per session ✅ Stored in a <​meta> tag ✅ Auto-attached to cart API calls So now: The malicious site tries the same trick But Amazon’s backend checks: Where’s the anti-csrftoken-a2z header? The attacker’s site can’t read or include that token (thanks to CORS + Same-Origin Policy) #csrf → Request is rejected immediately The token acts like a secret handshake between the real Amazon frontend and its backend. this is a good example of frontend security in action

2,266

37 Comments

System Design is the language of scale, and every engineer needs to speak it. I’ve created this 1-page Quick Guide to help you decode complex system design topics at a glance. Why does it matter? ✅ Big tech interviews are incomplete without system design ✅ Real-world systems break if you ignore concepts like latency, replication, or retries ✅ And whether you're working on backend, infra, or cloud - system design is the glue that holds your solution together This visual distills everything into 5 core sections: 🧠 Core Concepts — From CAP theorem to vertical vs horizontal scaling 🧩 Key Components & Tools — Load balancers, databases, object stores, CDN, containers, service mesh ⚙️ Reliability & Fault Tolerance — Health checks, chaos testing, retries, failover logic 📊 Monitoring & Observability — Tracing, logging, metrics, dashboards 📐 Design Patterns — Circuit breaker, BFF, bulkhead, event-driven flows You’ll also find foundational system terms like rate limiting, cold start, session stickiness, service discovery, and more - all mapped for clarity. 🧭 Whether you're a: Developer preparing for interviews Tech lead managing architecture Or someone transitioning to system design This guide will help you think better, build smarter, and scale with confidence. 👉 Save, share, and comment below if you want deep dives on any of these blocks. Let’s make system design simple, and scalable.

788

48 Comments

Must read for web developers !! Ever wonder what’s inside a modern web browsers ? This 4-part Chrome series explains it well: Part 1: Architecture Basics: https://lnkd.in/d4H_VVnh Part 2: Navigation Flow : https://lnkd.in/dxMtc3mK Part 3: Rendering & Resources : https://lnkd.in/dsvtSCdX Part 4: Events & Interactions : https://lnkd.in/dSvA4mxa #WebDev #FrontendEngineering

27

At Buffer, we are gradually migrating our entire Android app to our new GraphQL API and at the same time, migrating these features to Jetpack Compose away from our legacy UI implementations. All of this work is implemented behind feature flags, allowing us to gradually test and rollout these changes. While this has meant keeping both REST + GraphQL, along with Compose and XML implementations side-by-side, we're finally at the point where we can start removing these old implementations. Feature flag logic can get complex when approaching things this way, but bad experiences for users and the risk of slow app-store review times bring much more complexity 😅 This diff count is for the removal of all our legacy Post API and UI - what we use to show all of your posts in Buffer across different views. At Buffer we support 12 different networks (instagram, linkedin etc), many of which require us to display different information within these UI components, as well as having to handle different UI for each of their different use cases (queued, sent, drafts, approvals, calendar etc) - it's a lot of code but it also needs to handle a lot of use cases and logic (a lot of it was also Java 😅). The new code for this is a fraction of this, enabled by the simplicity of Jetpack Compose. The handling of different UI components for different Post states becomes easy with the slot based API and conditional composition. We tied these rewrites to other product related work, but there is benefit outside of this - we'll be able to move much fast in these parts of the code and not only does the app feel smoother in these parts, but we'll unlock more efficiency as AI agents will now have more success in understanding and performing changes in this codebase. As we migrate more of the core parts of our app in these ways, I'm looking forward to seeing more of these benefits come through!

241

16 Comments

iOS Architecture: 1. Refers to the high-level structure of an iOS app. 2. Determines how different components of the app interact and how the app is organised. 3. Example patterns: MVC, MVVM, VIPER, Clean Architecture. 4. Concerned with scalability, maintainability, testability, and separation of concerns. iOS Design: 1. Refers to the implementation details within components. 2. Focuses on how a specific feature or module works internally. 3. Includes UI/UX design, class design, method interactions, data flow, and design patterns like Singleton, Observer, Delegate, Strategy. 4. Concerned with code quality, reusability, and efficiency. iOS Example: Architecture Example: Using MVVM Model → Holds data View → Displays UI ViewModel → Binds data to the view Design Example: Inside ViewModel Using Singleton for network manager Using Delegate to communicate from a service to ViewModel

97

4 Comments

After spending months building a full course on System Design, I’ve realised this - 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 𝗶𝘀𝗻’𝘁 𝗮𝗯𝗼𝘂𝘁 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀. 𝗜𝘁’𝘀 𝗮𝗯𝗼𝘂𝘁 𝗳𝗮𝗶𝗹𝘂𝗿𝗲-𝗽𝗿𝗼𝗼𝗳 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗺𝗮𝗸𝗶𝗻𝗴 𝘂𝗻𝗱𝗲𝗿 𝗽𝗿𝗲𝘀𝘀𝘂𝗿𝗲. 𝗡𝗼𝘁: “I know WebSockets” 𝗕𝘂𝘁: “How do I ensure message durability during network drops?” 𝗡𝗼𝘁: “I’ve used Redis” 𝗕𝘂𝘁: “When should I choose Redis Streams over Kafka for real-time systems?” 𝗡𝗼𝘁: “I shard my DB” 𝗕𝘂𝘁: “How do I reshard on the fly without data loss?” 𝗡𝗼𝘁: “I use retry queues” 𝗕𝘂𝘁: “How do I implement exponential backoff with dead-letter handling?” Checkout the free course here -> https://lnkd.in/gU6VY56J

127

2 Comments

𝗧𝗵𝗲 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗱𝗶𝗱𝗻’𝘁 𝗷𝘂𝘀𝘁 𝘁𝗲𝘀𝘁 𝗺𝘆 𝘀𝗸𝗶𝗹𝗹𝘀. 𝗜𝘁 𝘁𝗲𝘀𝘁𝗲𝗱 𝗺𝘆 𝗽𝗮𝘁𝗶𝗲𝗻𝗰𝗲 𝗮𝗻𝗱 𝗺𝗶𝗻𝗱𝘀𝗲𝘁. 𝗔𝗻𝗱 𝘁𝗵𝗮𝘁 𝗰𝗵𝗮𝗻𝗴𝗲𝗱 𝘁𝗵𝗲 𝘄𝗮𝘆 𝗜 𝗹𝗼𝗼𝗸 𝗮𝘁 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄𝘀 𝗻𝗼𝘄. I recently went through a senior engineering interview process at Adobe. 5 rounds. Different styles. Different expectations. Some friendly. Some not so much. But every round taught me something important. So I wrote this post not to talk about the result, but about the lessons worth keeping. Sharing them here for anyone preparing for senior roles. 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀 𝗮𝗻𝗱 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀 👇 🧠 𝗦𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 𝗶𝘀 𝗻𝗼𝘁 𝗮𝗯𝗼𝘂𝘁 𝗱𝗿𝗮𝘄𝗶𝗻𝗴 𝗯𝗼𝘅𝗲𝘀 𝗮𝗻𝗱 𝗮𝗿𝗿𝗼𝘄𝘀 It is about understanding real constraints. Talk about concurrency. Failure points. Scaling decisions. Cost. Trade offs. Interviewers notice when you think beyond the whiteboard. They want depth, not a template answer. 🧵 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 𝗶𝘀 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝘂𝘀𝗶𝗻𝗴 𝗹𝗼𝗰𝗸𝘀 In one round, I had to design a thread safe HashMap. The trick was not syntax. It was about understanding real world issues, like race conditions and optimization. Break your own design. Find cracks. Fix them. That impresses interviewers more than a perfect code block. 😶 𝗡𝗼𝘁 𝗲𝘃𝗲𝗿𝘆 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄𝗲𝗿 𝘄𝗶𝗹𝗹 𝗯𝗲 𝗲𝗮𝘀𝘆 𝘁𝗼 𝘄𝗼𝗿𝗸 𝘄𝗶𝘁𝗵 One round felt like a debate. Lots of interruptions. Some confusion. It happens. Stay calm. Re-structure your points. Do not argue, guide the conversation. Your patience is also being evaluated. 💬 𝗚𝗼𝗼𝗱 𝗱𝗶𝘀𝗰𝘂𝘀𝘀𝗶𝗼𝗻𝘀 𝗹𝗲𝗮𝘃𝗲 𝗮 𝘀𝘁𝗿𝗼𝗻𝗴𝗲𝗿 𝗶𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 𝘁𝗵𝗮𝗻 𝗽𝗲𝗿𝗳𝗲𝗰𝘁 𝗮𝗻𝘀𝘄𝗲𝗿𝘀 One of the best rounds wasn’t about getting everything right. It was about walking through the thought process together. That matters more than jumping straight to the final solution. 🧩 𝗦𝗲𝗻𝗶𝗼𝗿 𝗿𝗼𝗹𝗲𝘀 𝗿𝗲𝗾𝘂𝗶𝗿𝗲 𝘄𝗶𝗱𝗲 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 Recursion, memory exhaustion, parallelism, cache eviction, databases, scalability. All in one round. Senior interviews are not about solving one problem. They check how you think across domains. Build both depth and range. 𝗠𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆 Interviews are not exams. They are conversations about your engineering mindset. Sometimes intense, sometimes unclear. But if you stay patient, explain your reasoning, ask good questions, and think practically, you stand out. If you are preparing for senior roles, focus less on remembering solutions and more on thinking like an engineer. That’s what changes the game. Happy to share prep resources if anyone needs them. Good luck to everyone building for the next step. 🚀

39

16 Comments

🚀 𝗖𝗿𝗮𝗰𝗸 𝗙𝗿𝗼𝗻𝘁𝗲𝗻𝗱 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄𝘀 𝗮𝘁 𝗣��𝗼𝗱𝘂𝗰𝘁-𝗕���𝘀𝗲𝗱 𝗖𝗼𝗺𝗽𝗮𝗻𝗶𝗲𝘀! Landing a frontend engineering role at a top product-based company requires structured preparation across multiple rounds. Here’s your step-by-step guide to ace it! 🟢 𝗥𝗼𝘂𝗻𝗱 𝟭: 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 (𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀 + 𝗖𝗼𝗱𝗶𝗻𝗴) 📌 Key Topics to Master: ✅ Core Concepts: Scope, Hoisting, Closures, Event Loop ✅ Tricky Output-Based Questions: this, Prototypes, Execution Context ✅ Polyfill Implementations: bind(), debounce(), throttle(), reduce(), Promises, Object methods, useState, new keyword 💻 Coding Challenges: ✔️ Promises & Async/Await ✔️ Prototype & Constructor Functions ✔️ Complex Promise Batching 🟠 𝗥𝗼𝘂𝗻𝗱 𝟮: 𝗗𝗮𝘁𝗮 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝘀 & 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 (𝗘𝗮𝘀𝘆-𝗠𝗲𝗱𝗶𝘂𝗺 𝗟𝗲𝘃𝗲𝗹) 📌 Must-Know Topics: ✅ Data Structures: Arrays, Strings, Objects (Most frequently asked) ✅ Basic DSA Concepts: Recursion, Linked Lists, Trees 🔥 Algorithms to Focus On: ✔️ Binary Search – Optimize your solutions efficiently ✔️ Sliding Window & Two Pointers – Crucial for array problems ✔️ BFS & DFS – Essential for trees/graphs 🔵 𝗥𝗼𝘂𝗻𝗱 𝟯: 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗖𝗼𝗱𝗶𝗻𝗴 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 (𝟰𝟱-𝗠𝗶𝗻 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲) 📌 Common Tasks: ✅ OTP Input Box ✅ Nested File System ✅ Carousel Component 🛠️ Cracking Strategy: 1️⃣ Implement core functionality first 2️⃣ Focus on scalability (make it configurable) 3️⃣ Optimize styling & structure 💡 Use a component-driven approach for React-based challenges. 🟣 𝗥𝗼𝘂𝗻𝗱 𝟰: 𝗙𝗿𝗼𝗻𝘁𝗲𝗻𝗱 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 📌 Think like a Frontend Architect! ✅ Requirement Breakdown: Functional (FR) & Non-Functional (NFR) requirements ✅ Architecture Design: Folder structure, state management, component breakdown ✅ Data Modeling: API contracts, local/global state ✅ Interface Definition: API integration, caching strategies ✅ Performance Optimization: Lazy loading, memoization, CDN strategies 💡 Pro Tip: Prioritize scalability, performance, and maintainability in your design decisions. 🎯 𝗙𝗶𝗻𝗮𝗹 𝗧𝗶𝗽𝘀 𝘁𝗼 𝗔𝗰𝗲 𝘁𝗵𝗲 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 ✔️ Stay consistent with DSA + JavaScript practice ✔️ Master React fundamentals – Hooks, Performance Optimization, Patterns ✔️ Write clean, scalable code ✔️ Practice mock interviews to boost confidence 🔥 Want more tips on cracking tech interviews? 🔹 Follow me for insights on frontend, system design, and career growth! 🔹 Drop your questions in the comments, and let’s discuss!

20

3 Comments

💥 Mount Mayhem at Netflix: Scaling Containers on Modern CPUs Hi LinkedIn community 👋 Jai Shree Krishna 🙏 Imagine this — you hit Play on Netflix on a Friday night 🍿 and behind the scenes, hundreds of containers spin up within seconds to stream your favorite show. At Netflix, scaling containers efficiently isn’t just an optimization — it’s mission-critical. But recently, their team hit a surprising bottleneck while modernizing their container runtime — not in Kubernetes, not in containerd, but deep in the CPU architecture itself. 1)⚙️ The Hidden Problem Netflix was migrating from their Virtual Kubelet + Docker setup to a modern Kubelet + Containerd environment. As traffic scaled, some nodes began stalling for over 30 seconds, even during basic health checks. The system logs revealed something unusual — the mount table length was exploding. Systemd was choking on mount events, kubelet was timing out, and container startups were freezing. Most affected nodes were r5.metal instances, especially when starting images with 50+ layers. 2)🔍 Root Cause: Mount Lock Contention The flamegraph told the truth containerd was spending most of its time waiting for a kernel-level mount lock. 3)Here’s why 👇 Each container layer requires: open_tree() to reference the layer mount_setattr() to apply UID/GID mappings move_mount() to bind-mount it with new idmaps When 100 containers start, each with 50 layers, containerd must perform over 20,000 mount/umount operations — each needing global VFS locks. As a result, every CPU was busy waiting on this shared lock, causing severe contention and stalls across the node. 4)🧩 Why It Happened In the old runtime, all containers shared one host user range. UIDs were shifted at image extraction time. In the new runtime, each container gets its own host user range (via Linux idmap) for stronger isolation. This eliminates UID rewriting but massively increases mount operations since every layer must be remounted with its namespace applied. So, while idmap improved security and efficiency, it unintentionally triggered CPU lock contention at scale — especially on large, multi-core instances. 5)🧠 The Key Insight This wasn’t a Kubernetes bug. It wasn’t containerd. It wasn’t AWS. It was a hardware-level scaling issue caused by global kernel VFS locks. Netflix engineers discovered that when scaling thousands of containers rapidly, even kernel-level serialization can throttle performance — proving that true scalability requires visibility beyond the software layer. 6)🚀 The Takeaway Netflix’s journey shows that at hyperscale, the bottleneck can live anywhere — even inside the CPU’s locking mechanism. Performance engineering isn’t just about writing faster code. It’s about understanding the entire stack — from container runtimes to kernel internals. When you’re operating at Netflix’s scale, “modern CPUs” become part of the engineering challenge itself. #NetflixEngineering #Containers #Kubernetes #Linux

45

21 Comments

How does Uber find the 5 closest drivers to you in less than 200 ms? One of the most common System Design interview questions. Let’s imagine you have your own location — latitude and longitude. When you request a taxi or search for nearby places in an app, you get a response almost instantly. But how does that actually work behind the scenes? Suppose we store all driver locations in a simple table like this: taxiId | latitude | longitude 1   | 12.312  | 43.423 Of course, we could add indexes to these columns, but that won’t help much — the dataset is huge. If we try to find all rows where latitude is between 43.300 and 43.500, we’ll still get thousands of results. And we can’t efficiently combine that with longitude filtering. So, how can we quickly get the list of drivers closest to our location? The answer is GeoHash. With GeoHash, the world is divided into rectangular regions, and each object (like a driver or restaurant) is assigned to one of these rectangles. Then, to find nearby objects, we simply check which drivers fall inside the same or neighboring rectangles. This data can also be stored in memory and distributed across regions — keeping response times below 200 ms. But there’s another challenge: What if some rectangles (like those in city centers) are too crowded, while others are almost empty? I’ll explain how to handle that in Part 2 Perhaps you’ll never see me again — follow me to get more. #SystemDesign #FAANG #MAANG #Netflix #Apple #Amazon #Google #Facebook #Twitter #DesignPatterns #Uber #LeetCode #LiveCoding

416

29 Comments

𝗢𝗢𝗣𝘀: 𝗧𝗵𝗲 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗥𝗼𝘂𝗻𝗱 𝗧𝗵𝗮𝘁 𝗟𝗼𝗼𝗸𝘀 𝗘𝗮𝘀𝘆 — 𝗕𝘂𝘁 𝗜𝘀𝗻’𝘁. You’ve used classes. You’ve created objects. But when asked to explain the "why" behind OOPs, many candidates freeze. In most interviews, OOPs isn’t tested like a definition round. It’s used to check how deeply you understand software design. Here are some of the most commonly asked OOPs interview questions: 🔹 What are the 4 pillars of OOP? 🔹 Abstraction vs Encapsulation — real-world example? 🔹 Interface vs Abstract Class — when to use what? 🔹 Method Overloading vs Method Overriding 🔹 SOLID Principles — and why they matter 🔹 Is multiple inheritance supported in Java or Python? These aren’t trick questions — but they separate coders from software thinkers. 📩 Want a clean, curated PDF of most-asked OOPs questions with examples? → Follow @Topperworld → Comment “OOPs” below → Get the PDF directly in your inbox! 🔁 Repost to help others strengthen their fundamentals. OOPs isn’t just a chapter — it’s the core of clean code. #OOPs #Java #ObjectOrientedProgramming #TechInterviews #Topperworld #InterviewPreparation #CodingInterview #SoftwareEngineering #DSA #CleanCode #CareerPrep

73

13 Comments

#Linkedin 🤯 Most asked concept in Machine Coding & Frontend System Design Interview - "Intersection Observer" 👇👇👇 🚀 Let's Understand "Intersection Observer" Intersection Observer API is a modern browser API that allows you to detect when an element enters or exits the viewport (the visible part of the browser window). It's beneficial for implementing features like lazy loading images, infinite scrolling, or triggering animations as an element comes into view. 🚀 How It Works ? The IntersectionObserver is constructed with a callback function that will be executed when the target element enters or exits the intersection area with the root. *️⃣ You can customize how the observer works by setting options like: 👉 root: The element that is considered the viewport for the intersection check. By default, it is the browser viewport. 👉 rootMargin: A margin around the root element. This is like extending or shrinking the viewport for intersection purposes. 👉 threshold: A value between 0 and 1 that determines how much of the target element must be visible before the callback is triggered. For example, a threshold of 0.5 means the callback is fired when 50% of the target element is visible. 🏅 Checkout FrontendGeek.com to prepare for all frontend interview rounds 🙏Follow FrontendGeek & Anuj Sharma for more frontend related stuff #frontend #intersectionobserver #interview #frontendinterview #uiinterview #jsinterview #javascriptinterview #frontendgeek

90

9 Comments

Spring Boot has revolutionized the Java development ecosystem by enabling rapid application development with minimal boilerplate. One of its core features is auto-configuration, but what exactly is being auto-configured and how does Spring Boot make those decisions? Q1: What triggers auto-configuration? Q2: How does Spring Boot know which classes to auto-configure? Q3: Can I see which configurations were applied? Q4: How can I exclude a specific auto-configuration? Q7: How can I create my own auto-configuration? Q10: Can auto-configuration be modular? Get the discussion in the below medium article --> https://lnkd.in/gND58KBv #springboot #spring #java #interview #deepdive #learning #codefarm

47