Lavesh Kaushik

𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 𝗧𝗮𝗹𝗸𝘀 #𝟭 — 𝗛𝗼𝘄 𝗡𝗲𝘁𝗳𝗹𝗶𝘅 𝗦𝗰𝗮𝗹𝗲𝘀? If someone asks you to design Netflix in a system design interview, saying “𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 + 𝗖𝗗𝗡” is not enough. 𝗟𝗲𝘁’𝘀 𝘁𝗵𝗶𝗻𝗸 𝗮𝗯𝗼𝘂𝘁 𝗶𝘁 𝗽𝗿𝗼𝗽𝗲𝗿𝗹𝘆. 𝗧𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝗿𝗲𝗮𝗹 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗡𝗲𝘁𝗳𝗹𝗶𝘅 𝗳𝗮𝗰𝗲𝘀 𝗶𝘀 𝗯𝗮𝗻𝗱𝘄𝗶𝗱𝘁𝗵 𝗮𝗻𝗱 𝗹𝗮𝘁𝗲𝗻𝗰𝘆. Video streaming is extremely heavy compared to typical web traffic. If every stream came from a centralized data center, network congestion and latency would kill performance. That’s why Netflix uses a global CDN. Video content is pre-replicated across edge locations. When you press play, your request is routed to the nearest edge server. The key idea here is understanding that data transfer, not compute, which becomes your primary bottleneck in media systems. 𝗧𝗵𝗲 𝘀𝗲𝗰𝗼𝗻𝗱 𝗺𝗮𝗷𝗼𝗿 𝗰𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 𝗶𝘀 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝘂𝗻𝗽𝗿𝗲𝗱𝗶𝗰𝘁𝗮𝗯𝗹𝗲 𝘁𝗿𝗮𝗳𝗳𝗶𝗰 𝘀𝗽𝗶𝗸𝗲𝘀. Evening peak hours can multiply traffic several times. Instead of scaling a monolithic backend, Netflix isolates responsibilities into independent services (eg. playback, recommendations, user profiles, billing.) Why is that important? Because different components scale differently. Playback scales with concurrent users. Billing scales monthly. Recommendations scale per user session. 𝗧𝗵𝗲 𝘁𝗵𝗶𝗿𝗱 𝗰𝗿𝗶𝘁𝗶𝗰𝗮𝗹 𝗽𝗶𝗲𝗰𝗲 𝗶𝘀 𝗰𝗮𝗰𝗵𝗶𝗻𝗴. Imagine millions of users requesting metadata for the same trending show. Without caching, your database becomes the single point of failure. Netflix aggressively caches popular titles, frequently accessed metadata and session data. A note to take here: At scale, database optimization is not enough. You must reduce database dependency. 𝗔𝗻𝗼𝘁𝗵𝗲𝗿 𝘂𝗻𝗱𝗲𝗿-𝗱𝗶𝘀𝗰𝘂𝘀𝘀𝗲𝗱 𝗰𝗼𝗻𝗰𝗲𝗽𝘁 𝗶𝘀 𝗳𝗮𝗶𝗹𝘂𝗿𝗲 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴. Distributed systems fail in subtle ways- -> Network partitions -> Partial outages -> Slow downstream services Netflix practices chaos engineering to simulate failures intentionally. Why? Because large-scale systems must be designed assuming failure, not assuming stability. In interviews, mentioning retries, circuit breakers, and graceful degradation shows maturity. 𝗙𝗶𝗻𝗮𝗹𝗹𝘆, 𝗽𝗲𝗿𝘀𝗼𝗻𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻. Your Netflix homepage isn’t static. It’s generated based on: -> User history -> Real-time engagement -> Ongoing A/B experiments That means large-scale data processing pipelines run continuously behind the scenes. So scaling Netflix is more about 𝙨𝙩𝙧𝙚𝙖𝙢𝙞𝙣𝙜 + 𝙙𝙞𝙨𝙩𝙧𝙞𝙗𝙪𝙩𝙚𝙙 𝙘𝙤𝙢𝙥𝙪𝙩𝙖𝙩𝙞𝙤𝙣 + 𝙙𝙖𝙩𝙖 𝙥𝙞𝙥𝙚𝙡𝙞𝙣𝙚𝙨 running simultaneously. It’s about identifying your real bottleneck instead of adding just more servers. Good system design is constraint-driven thinking. If you were asked to design Netflix in an interview, what would you optimize first? #SystemDesign #SoftwareEngineering #Netflix

31

4 Comments

🍀 6 months at Google.... Today I have completed 6 months at Google after having joined back in January 27th, 2025. These 6 months have been a rollercoaster of learning, exploration, meeting some exceptionally skilled people, and growth. Summarizing my journey at Google, here's the top 6 learnings for me over the period of the last 6 months... 1️⃣. Imposter Syndrome is real - Working at a place like Google, the talent density is the real deal. With being surrounded by some the smartest folks in the industry and working alongside them, its easy to feel lost and out of place. 2 things kept me going here - a. The support from the team in my rampup. b. The confidence that I've done harder things in the past - this too shall pass. 2️⃣. Ownership matters - At a place like Google, with highly skilled people all around, its kinda obvious that people like to own their work and expect you to do the same. How to own your work end to end, and to deliver it with the highest quality is something I've greatly learnt in the past few months. 3️⃣. Communication >>> Code - At a place, where any code change you make affects billions, communication and alignment regarding the same becomes something of utmost nessecity. Skillful communication within the team, cross teams, and with multiple stakeholders to effectively deliver work is something I've seen matter more than ever here. 4️⃣. Asking for help is a strength - In companies like Google and Microsoft, asking for help is looked on as a strength, not a weakness. The culture fosters that. However, to get help, you've to ask for it. Getting over the thought of judgment, to reach out for help, is a key learning which helped me a lot in the journey. 5️⃣. Make meaningful connections - Walking in any journey, what makes it worthwhile are the friends you make along the way. Making intentional connections, and going out of the way to help others move ahead in their journey, is the way to move ahead in the journey. This is something I also try to incorporate in my Linkedin journey by trying to give back to the community. 6️⃣. You're never too good at something, Keep learning - Tech is a fast moving space. The thought of "I already know enough" becomes obsolete as fast as the tech of today. Its a journey of constant of learning and upskilling. Parallely, make your basics stronger, that's what allows you to keep up the learning pace, with the industry. The last 6 months have been really exciting, fun, full of learnings and challenges all along the way. As its said in Google, being a Noogler is like "trying to drink from a firehose". Really excited for what the next 6 months unfolds. Stay tuned for more such content!!✌🏻🚀

907

85 Comments

Was reading a bit on serving LLMs and space is rapidly evolving. Found vLLM (Liang et al., 2023) quite interesting. It introduced a mechanism called PagedAttention, which virtualizes the KV (key-value) cache by managing it like a paged memory system. In transformer models, the KV cache stores intermediate attention values for previously seen tokens—essential for generating the next token without recomputing everything from scratch. Instead of keeping this entire cache in GPU memory, which grows linearly with prompt and response length, PagedAttention evicts and loads cache blocks on demand. This enables long-context inference without exhausting GPU memory and is a foundational step toward memory-aware serving. Google’s Pathways architecture takes a related route, by conditionally activating only the parts of a model relevant to a given input—known as expert routing. This sparsely activates subsets of model parameters (called "experts") rather than loading the full model, saving compute and memory. Although these architectures focus on model modularity rather than serving infra modularity. Microsoft’s DeepSpeed Inference and MII optimize serving by reducing the resource load of each inference phase and employ techniques such as KV cache sharing, where multiple concurrent requests can reuse the same cache entries instead of duplicating memory; and activation offloading, which temporarily moves intermediate computations (activations) from GPU memory to CPU or host memory during inference to avoid exceeding memory limits. These optimizations allow each GPU to serve more concurrent decode requests without degrading throughput or accuracy. NVIDIA’s Dynamo is currently one of the most complete implementations of fully disaggregated inference. It explicitly splits prefill and decode phases into different GPU pools. A Smart Router component directs decode requests to the GPUs where the relevant KV cache already resides, minimizing cache transfers or recomputation. A separate KV Cache Manager coordinates cache eviction and loading across a hierarchy of memory layers—including GPU VRAM, CPU RAM, SSD, and even networked object stores—similar to how virtual memory systems operate. Meta’s LlamaServe, built on Triton Inference Server, is still in early stages but is beginning to explore smarter scheduling and batching of requests. Across all of these systems, a common trend is taking shape. Inference is no longer treated as a uniform, atomic task. If you're working on inference infrastructure, I’d love to hear more on this from you! #inference

8

Sheetal Singh & I have been paring for over a month on some Rust OSS projects: our first submission to the community is Parseltongue - came out of the need for code-noobs like me to understand code at the abstract level of LLDs - as Interface Signature Graphs - which expresses the overall structure of code in just 5% of total code LOC / tokens - or even lesser - so you can reason with the codebase in far lesser context window every time you update the code, within a few milli-seconds you will be able to see the updated ISG as a visualization and can also find the blast radius of the change you intend so you can run it as - a live code daemon - a gitingest txt codebase analyzer (we did it for tokio library) our work is primary inspired by Shreyas Doshi's Product Sense course - which both of us attended and which nudged us to think for ourselves on problems seeking a differentiated experience for our users via the tools / libraries this is an initial draft & we will be applying to delta residency with this idea seek feedback from folks on what we could improve further link to github repo in first comment our vision with Parseltongue: use Interface Signature Graphs to reason large codebases with LLMs in a faster & more accurate manner onbv 🙏

20

1 Comment

Ever needed to run a regex search on your dataset—only to watch your queries crawl while your users tap their feet? You collect tons of log lines, events, or messages in your favorite analytics database and want to surface exceptions, patterns, or keywords with a quick REGEXP search. But as your data grows, those once-snappy queries start to lag... and lag... and lag. So why does this happen?   A basic regex search forces your database to inspect every value— O(n) time for n records. If you’ve got 100 million rows, even a blazing-fast system starts sweating. Now you start thinking: Can I make this faster with indexing? What options are there? - Start simple: Use a dictionary scan. If your text field has low cardinality—a few repeated values—Pinot’s dictionary scan is O(d), much better than O(n). But if that dictionary is huge? Performance still drags. - Get smarter: Enter Lucene's FST (Finite State Transducer) Index. It builds an automaton (think: compressed trie) that encodes all possible field values as a searchable graph. Now, rather than scanning the whole dataset, It matches your regex just once across the FST— O(k) time for your regex pattern length! Suddenly, 30-second queries finish in milliseconds, no matter the table size. - Still want more? Add inverted index alongside FST. For complex queries—mixing regex and filters—you get lightning-fast bitmap matching plus rapid regex search. Regex is fast, filters are fast, and everything stays real-time. But is indexing worth it? You might worry about extra storage or write overhead. What if you get all of these. Here comes Pinot’s FST(link in comment) and inverted indexes are so efficient you can build them inline, as new data lands in real-time. A tiny storage premium for massive query speedups—an unbeatable trade-off, especially as your workloads scale. Have you hit the same regex wall? What tricks helped you push past it? If you’re in Bangalore and want to geek out on real-time indexing and analytics internals—you would want to be at Meesho tech (https://lnkd.in/gDM2t8EZ) meetup. That’s where the latest Pinot tips and deep dives are brewing! StarTree Meesho Gnanaguru SattanathanJayesh Asrani #DataEngineering #IndexingMatters #BigData #PerformanceOptimization #ApachePinot #MeeshoTech #RealTimeAnalytics

11

1 Comment

Cloudflare is down AGAIN! From Zerodha, Groww, to Canva, Zoom, Discord and SaaS platforms, users were hit with 500 Internal Server Errors and Bad Gateway screens across the board. When a company like Cloudflare goes down, it isn’t “a website issue.” - It’s a global infrastructure event. - Impact on trade during active market hours. - Zerodha even had to route users to WhatsApp for order management - Even DownDetector, the site we all rush to check if the internet is down, was itself down. Because Cloudflare isn’t just a CDN. It’s the backbone layer for: - API routing - DNS - DDoS protection - Load balancing - Reverse proxy - Global traffic acceleration Take that layer out, even briefly, and entire businesses stall. ⚠️ What makes this outage significant is not just the scale, but the timing: - Trading platforms, payment gateways, and high-traffic consumer apps all experienced visible downtime. And here’s the uncomfortable truth: 👉 When you’re dependent on a single network edge provider, your uptime becomes their uptime. This outage is a reminder for engineering teams to think beyond the happy path: - Do you have multi-CDN fallback? - Can your critical APIs bypass Cloudflare if needed? - Is your DNS redundant across providers? - Can your app degrade gracefully without edge caching? Cloudflare will fix the issue. But the question is, will companies rethink their dependency layers after this? - The outage wasn’t just a technical incident. - It was a resilience test for the modern internet. #Cloudflare #CloudflareDown #TechNews #StockMarket #Zerodha #DevOps #InternetOutage

2,290

69 Comments

Beyond "Caching Images": What SDE-2/L5 Engineers Must Know About CDNs 🌐 Most junior engineers think a CDN is just a "vending machine" for static images. But if you're interviewing for a Senior role, you need to go much deeper. I’ve been diving into the distributed systems architecture of modern CDNs. Here are the 5 pillars of CDN deep-dives: 1. The Multi-Tier Topology A CDN isn’t just one server. It’s a hierarchy: L1 (Edge): Small, lightning-fast SSD caches inside ISP data centers. L2 (Regional): Larger buffers that sit between L1s and your Origin. The Goal? Preventing a "Cache Stampede"—where 1,000 Edge servers all hammer your Origin at once when a file expires. 2. Request Routing: DNS vs. Anycast How does a user find the "closest" server? DNS-Based (CloudFront): Granular control using EDNS-Client-Subnet, but limited by DNS TTL "stickiness." Anycast (Google/Cloudflare): BGP routes users to the nearest PoP. It offers near-instant failover but is harder to make "load-aware." 3. Caching Lifecycle (Consistency is Hard) Standard TTL isn't enough for scale. Seniors use: Surrogate Keys: Tagging assets so you can invalidate an entire product category with one API call. Stale-While-Revalidate: Serving "expired" content to the user instantly while fetching the fresh version in the background. Zero-latency updates. 4. The "VIP Lane": Dynamic Site Acceleration (DSA) 🚀 This is the most underrated CDN feature. How do you speed up a shopping cart or a stock trade that can't be cached? TCP Connection Pooling: Keeping "warm" connections open to the Origin to skip the 3-way handshake. Route Optimization: Bypassing the public "wild west" internet by using the CDN's private fiber backbone. SSL Termination: Doing the heavy encryption handshake at the Edge (50 miles away) rather than the Origin (5,000 miles away). 5. Security at the Edge Modern CDNs are the first line of defense: WAF: Scrubbing SQLi and XSS before they hit your VPC. DDoS Absorption: Using massive bandwidth to "soak up" SYN floods. Edge Compute: Moving logic (Auth, A/B testing) into Lambda@Edge or Cloudflare Workers to reduce Origin round-trips. The SDE-2 Takeaway: When designing global systems, don't just "add a CDN." Discuss the trade-offs between Consistency and Latency. What’s your preferred cache invalidation strategy? Versioning or Purging? Let's discuss in the comments! 👇 #SystemDesign #SoftwareEngineering #DistributeSystems #SDE2 #CodingInterview

6

My post explaining LLMs from scratch was top post on r/DevelopersIndia yesterday. 😁 Read here: https://lnkd.in/gXMYMcWs (after a *year* of procrastination 🌚) I've always enjoyed explaining technical topics to non-technical people. Why? Because the advantages of having even a 𝘭𝘪𝘵𝘵𝘭𝘦 knowledge is HUGE, and you can see the difference you make in their lives. ----- If you've ever given your car for repairs, you know what I mean. I had 0 idea how it works. They drone on with sprockets and filters and gaskets. I just nod my head, pay and leave. 😶‍🌫️ But the next time I went, I just randomly asked him "𝘰 𝘳𝘪𝘯𝘨 𝘰𝘬𝘢𝘺 𝘥𝘩𝘢𝘯𝘢?" and it was like he was a different person. I got 𝘸𝘢𝘺 better explanations and left with a lot of newfound knowledge on how everything works. ----- It's the same in tech, especially now that LLMs are literally everywhere. 𝗔 𝘁𝗶𝗻𝘆 𝗯𝗶𝘁 𝗼𝗳 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗮𝗯𝗼𝘂𝘁 𝗵𝗼𝘄 𝗶𝘁 𝘄𝗼𝗿𝗸𝘀 𝘂𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗵𝗼𝗼𝗱 𝗰𝗮𝗻 𝗰𝗵𝗮𝗻𝗴𝗲 𝘁𝗵𝗲 𝗰𝗼𝘂𝗿𝘀𝗲 𝗼𝗳 𝗲𝘃𝗲𝗿𝘆 𝗰𝗼𝗻𝘃𝗲𝗿𝘀𝗮𝘁𝗶𝗼𝗻 𝘆𝗼𝘂 𝗵𝗮𝘃𝗲 𝗮𝗯𝗼𝘂𝘁 𝗶𝘁. You understand why ChatGPT is forgetting. You understand the very real security issues that come with LLMs. You understand random posts about MCP. You understand how Perplexity's new AI browser works. You can make judgements on what AI claims make sense and what's BS. Take 15 minutes today. It's a long read, but get started! Always open to feedback 😁

68

8 Comments

Before you say “send users to Japan,” that is not a valid option. xD Jokes apart, If the same backend and same code give 90 ms in Japan and 500 ms in India, my first assumption is: This is probably not an app code problem. It is usually a distance / network / edge / data path problem. Here is how I would answer it in an interview: Step 1: Break latency into parts I would ask: - How much is TTFB vs backend processing time? - Is the API server only in one region? - Where is the database? - Are we doing cross-region DB reads/writes? - Is TLS handshake / DNS / CDN / WAF different by geography? Because if backend compute is only 40–50 ms and Indian users still see 500 ms, the real issue is the path, not the handler. Step 2: Most likely fixes 1. Serve users from a closer region - Put app servers in India or a nearby APAC region - Use geo-DNS / Anycast / global load balancer to route users to the nearest healthy region 2. Move read-heavy data closer to users - Add regional read replicas - Cache aggressively at the edge for static or semi-static API responses - Use Redis in-region for hot keys 3. Reduce network round-trip - Avoid chatty APIs - Bundle dependent calls - Use connection reuse / keep-alive / HTTP/2 or HTTP/3 where possible 4. Put a CDN / edge layer in front - Good for auth-less content, metadata, configs, images, feature flags - Even dynamic APIs can benefit from edge caching if responses are cacheable Step 3: Be careful about the database This is where people mess up. If your app is in India but every request still writes to a DB in Japan, you just moved the bottleneck. So I would call out: - If reads dominate → regional replicas help a lot - If writes dominate → now we need to talk about multi-region write complexity, consistency, and whether the product can tolerate eventual consistency Step 4: How I would summarize it “My first move is not to change code blindly. I would measure where the 500 ms comes from. If the gap is due to geography, I would place compute and read paths closer to India using geo-routing, regional app servers, read replicas, Redis, and edge caching. If the database remains remote, that becomes the next bottleneck. So the real fix is reducing cross-region hops, not tuning one API handler.” That answer shows you understand: - latency decomposition - global architecture - caching - routing - consistency tradeoffs And that is what the interviewer usually wants.

965

135 Comments

Hate is the biggest form of flattery. During my time at Amazon, there was almost always someone unhappy with me — a manager, a peer, or a junior engineer. Not because I was difficult, but because I chose to do the right thing instead of taking sides. Early in my career, I tried hard to avoid offending anyone. Over time, I realized this: I’m not paid to keep everyone comfortable. I’m paid to think clearly, act fairly, and do what’s right for the team and the customer. This doesn’t mean ignoring alignment or team chemistry. It means being willing to push back, say no, or even stop something when necessary. If this resonates, here’s what to do: 1️⃣ Optimize for being right, not being liked 2️⃣ Disagree respectfully, but don’t stay silent 3️⃣ Seek consensus without diluting good decisions 4️⃣ Be willing to push back or say no 5️⃣ Accept that doing the right thing will upset someone Real impact rarely comes from playing it safe.

764

19 Comments

💰 Groww is not just adding users — it is upgrading the quality of the user base. The ARC’s breakdown shows the “Two Indias” inside Groww: 🟩 Aspirational India This is still the bulk of users + revenue. But their AARPU (average revenue per user) is almost plateauing near ₹8.2K annually. 🟪 Affluent India This small but fast growing segment is where the monetisation engine is firing. Affluent user assets on Groww grew at 163% CAGR since FY22. 📌 By FY25, affluent users controlled 31% of Groww’s total assets even though they are a much smaller base. That’s the big story. 🚀 Groww is quietly becoming a wealth platform — not just a broking platform. And as affluent share expands toward 33%+ (the FY26 projection), operating leverage goes vertical. The market obsession is always “DAUs & MAUs”. But real internet power is: 💵 more assets per customer ⏳ longer retention 📈 higher monetisation naturally This is exactly where Groww is heading. https://lnkd.in/gXp6GJ5F

1

"𝗜 𝗯𝘂𝗶𝗹𝘁 𝗺𝘆 𝗲𝗻𝘁𝗶𝗿𝗲 𝗽𝗼𝗿𝘁𝗳𝗼𝗹𝗶𝗼 𝗶𝗻 𝟯𝟬 𝗺𝗶𝗻𝘂𝘁𝗲𝘀 𝗱𝘂𝗿𝗶𝗻𝗴 𝗮𝗻 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝘁𝗵𝗮𝘁 𝘁𝗲𝗹𝗹𝘀 𝘂𝘀 𝗮𝗯𝗼𝘂𝘁 𝗔𝗜 𝗶𝗻 𝟮𝟬𝟮𝟲." There was this interview round where I had to 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲 𝗺𝘆𝘀𝗲𝗹𝗳. Instead of the usual elevator pitch, I decided to "vibe code" it—literally gave my AI assistant a bunch of instructions, and boom, 30 minutes later, I had a full website. The best part? I managed to grab vikasranjan[dot]com 🎉 https://vikasranjan.com/ Here's what got me thinking: What used to take weeks of design, development, and iteration now takes minutes. Not because I'm a wizard (though I do build AI systems 😄), but because the tools have evolved. A few years back, building a portfolio meant: • Hiring a designer • Waiting for mockups • Back-and-forth revisions • Months of development • Deployment headaches Today? A few prompts. A few tweaks. Done. This is what happens when you combine: ✓ Clear thinking about what you want ✓ AI as a tool (not a replacement) ✓ Willingness to experiment The real insight? The barrier to entry is gone. What's stopping you from building your portfolio, your side project, or that idea you've been sitting on? It's not the tools anymore. It's you. If you're still overthinking it—stop. The time is now. What's your take? Has AI changed how you approach building things?

35

4 Comments

Something I learned while building queue-based systems at Jio: Idempotency isn't optional in distributed systems -- it's survival. When you're processing 10M+ subscription events/month through RabbitMQ, duplicate messages WILL happen. Network retries, consumer restarts, broker redeliveries. Our solution: Redis-based deduplication keys with TTL. Every incoming message gets a hash. If the hash exists in Redis, skip processing. Simple, but it prevented duplicate customer charges. The lesson: Design for failure from day one. Your happy path will work. It's the retry path that breaks production. #BackendEngineering #DistributedSystems #NodeJS #SystemDesign

21

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

ChatGPT is executing a classic platform strategy, aiming to become the "prompt-based operating system" 🤯 Many vendors have tried the super-app concept (PhonePe, Tata Neu), but what ChatGPT is attempting is off the charts. The Vision: 📱 "Ask / Browse / Learn anything within ChatGPT" - Search / Browser 🛒 "Buy anything within ChatGPT" - Commerce / Fashion ⚡ "Prompt / Talk-to to get things done" - Productivity 🔗 "Run your business within ChatGPT" - CRM / Sales At their recent DevDay, OpenAI dropped the real game-changer that makes all this possible. 📲 Apps Inside ChatGPT: Forget app stores. Developers can now build their apps directly inside ChatGPT. Imagine using Canva, booking a flight, or listening to Spotify just by talking to ChatGPT. Major partners like Spotify, Figma and Coursera are already on board. What does this actually mean? ChatGPT is collapsing the roles of an operating system, an app store, and a personal assistant into one single, conversational platform. With over 800 million weekly users, the magnetic pull for developers to join is undeniable 🚀 Competition? Nowhere near when it comes to consumer market share. Gemini, Anthropic, Copilot and Perplexity will get their shares, but ChatGPT is leading the race. The Big Question: What happens when a single vendor essentially owns the "everything app"? 🤔 What's Next (my prediction)? ⏭️ Hardware that integrates with the ChatGPT ecosystem of apps. Probably a fork of Android that would be more 'prompt/talk-to' focused over the traditional touchscreen interface. Exciting times ahead! 🔮 I won't be surprised if Android smartphones sold next year advertise "Supports ChatGPT 2.0." Why 2.0? I have a strong feeling that ChatGPT apps will definitely require breaking out of the standard Android application sandbox.

7

🚀 System Design Insight: How Jio–Hotstar Manages Live Cricket Traffic (Beyond Auto-Scaling) Live cricket streaming is not a normal scaling problem. It’s emotion-driven, bursty, and unpredictable. A six by a popular cricketer can bring millions of users in seconds — and a boring over can send them right back to the home screen. 🏏 The Core Challenge User interest keeps oscillating during a match: ⭐ Star player appears → Live stream traffic spikes instantly 😴 Boring phase → Users hit Home, increasing movies & recommendation API load 🔁 This pattern repeats many times in a single match 👉 This makes pure auto-scaling unreliable. ❌ Why Auto-Scaling Alone Doesn’t Work Auto-scaling reacts after metrics change. But cricket traffic is Extremely sharp, Short-lived & Repeated frequently. This leads to Cold starts, Latency during scale-up & Unnecessary infra cost So for marquee matches, auto-scaling is intentionally restricted. 🧠 Smarter Design: Pre-Scale + Adaptive Resource Allocation 1️⃣ Live Streaming → Pre-Scaled & Stable Infrastructure is pre-warmed before match start No aggressive scale-down during the match CDN edges, streaming nodes, and socket connections stay hot This ensures smooth playback when traffic spikes suddenly. 2️⃣ Movies & Home APIs → Soft-Scaled, Not Shut Down When users shift to live streaming: Movie services are scaled down carefully Minimum warm instances are always kept Why? During boring moments, users return to Home, triggering - Trending movies ,Continue watching, Recommendations. Hard scale-down here would cause visible latency. Jio–Hotstar doesn’t scale only on CPU or RPS — it scales on human behavior. ✅ Pre-scaled live infrastructure ✅ Controlled auto-scaling ✅ Warm pools instead of cold shutdowns ✅ System design aligned with user psychology This is what real-world, production-grade system design looks like. #SystemDesign #Scalability #LiveStreaming #JioHotstar #DistributedSystems #BackendEngineering #CloudArchitecture

1