Pankaj Lohani

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

🚀 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

I'm a Software Engineer at AWS with 7+ years of industry experience. I've designed systems across CloudWatch, EC2, and Region Services. Some scaled well. Some broke at 2AM. Here are 15 system design lessons I learned the hard way: ► Before you build anything → Understand what you're solving before you start designing → There is no perfect solution — only tradeoffs you can live with → Assume everything will fail. Design for it. → Don't build what you don't need yet ► Data decisions will make or break you → SQL when you need ACID. NoSQL when you need flexibility. → Index for fast reads. Denormalise for read-heavy workloads. → Shard when one database isn't enough. Replicate so one failure isn't fatal. → Choose your partition key carefully — a bad one creates hot spots that ruin everything ► Scaling isn't magic → Scale horizontally. Vertical has a ceiling. → Put load balancers in front. Put CDNs at the edge. → Cache aggressively but know when your cache is lying to you. → Keep systems decoupled → Use queues between services. Sync calls create cascading failures. → Make operations idempotent. Retries will happen. → Async everything that doesn't need an immediate response ► The one that matters most → Design for the engineer debugging this at 3AM, not the one building it today --- ♻️ Repost to help someone with system design  ➕ Follow Abdirahman Jama for software engineering tips

1,732

49 Comments

There are two hard problems in distributed systems: 2. Exactly-once message delivery 1. Message ordering 2. Exactly-once message delivery 2. Exactly-once message delivery 2. Exactly-once message delivery 2. Exactly-once message delivery 2. Exactly-once message delivery 2. Exactly-once message delivery 2. Exactly-once message delivery 2. Exactly-once message delivery

63

5 Comments

Why we need raw pointers when we have smart pointers? (Someone asked it and post is vanished before I reply.) Smart pointers don’t replace raw pointers — they replace owning raw pointers. Most pointers in real systems are non‑owning, and raw pointers are still the best tool for that. We still need raw pointers for several reasons: 1. Non‑owning references Smart pointers express ownership. Most APIs need borrowed access: • observers • iterators • callback parameters • pointers into existing buffers • intrusive containers A smart pointer would be semantically wrong here. 2. Low‑level memory work Raw pointers are required when we need: • pointer arithmetic • strict aliasing control • alignment‑sensitive access • zero‑copy slicing into buffers This is essential when parsing binary protocols like PCAP, SBE, or custom wire formats. (FIX is ASCII, not binary, but high‑performance FIX parsers still use raw pointers internally to walk buffers without allocations.) 3. Interfacing with legacy or C APIs Large existing systems (finance, telecom, embedded, game engines) expose raw‑pointer‑based interfaces. We can’t wrap everything in smart pointers without changing semantics. 4. Memory that isn’t heap‑allocated Smart pointers are only for managing heap ownership. E.g. Smart pointers don’t know what to do with memory-mapped file or a stack address. Raw pointers are required for: • mmap regions • shared memory • GPU buffers • custom arenas • stack memory • static memory 5. Performance‑critical code shared_ptr has atomic refcounting. unique_ptr still implies heap ownership. In low‑latency systems, we often want: • no hidden allocations • no refcounting • no destructor overhead • deterministic lifetimes Raw pointers give zero overhead. Note: While raw pointers are "best," they should be used for observation, not lifetime management. Let’s see an example: The "Owner vs. Observer" Pattern: In this scenario, a Database owns the records, but a QueryEngine just needs to look at them. We use unique_ptr for the life-cycle and raw pointers for the work. class Record { public: int id; void print() { std::cout <<“Processing Record: " << id;} }; class Database { // 1. OWNERSHIP: Database owns the memory. // If the Database dies,the Records die. std::vector<std::unique_ptr<Record>> entries; public: void add(int id) { entries.push_back(std::make_unique<Record>(Record{id})); } // 2. OBSERVATION: We pass a raw pointer to the "worker". // We dnt want the worker to delete the record or share ownership. Record* get_record(int index) { return entries[index].get(); } }; void process_data(Record* r) { // 3. PERFORMANCE: No ref-counting, no allocations. // Just a direct memory address access. if (r) r->print(); } int main() { Database db; db.add(101); Record* ref = db.get_record(0); // Borrowing access process_data(ref); // Using raw ptr return 0; }

1

4 Comments

Prakhar's HLD for ~20,000,000 daily file uploads (part 2) let's see how that video appears on phone 1. Sync Signal 1. Phone's Dropbox client receives the sync notification 2. It checks with the Metadata Service for details about the new video 2. Metadata First 1. Client downloads the video's metadata first 2. Client see the video file in the folder list almost instantly, even before the content is there 3. On-Demand Download 1. When we tap to play the video, the client requests the block locations 4. Secure Block Retrieval 1. Block Service provides secure links for the phone to download each block 5. Parallel Download & Reassembly 1. Client downloads the blocks in parallel 2. it reassembles them into the original video file on the device 🤔 over to you, what are benefits of on-demand Download? Let me know in the comments! 👇 📣 Join 7-day email course to effectively optimize 60-minute system design interview - https://lnkd.in/gDBzCnE3 

62

23 Comments

System Design Part 2 Continuing my System Design Blog Series, this post is a deep dive into the Low-Level Design of WhatsApp. 📱 From handling 2 billion daily messages to ensuring high availability, we’ll walk step by step through how WhatsApp is architected at scale. 🚀 High-level estimate Here is our high-level estimate: TypeEstimateDaily active users: (DAU)50 million Requests per second (RPS) : 24K/s Storage (per day) : ~10.2 TB Storage (10 years) : ~38 PB Bandwidth : ~120 MB/s

6

🤯 Tricky Frontend Interview Questions for Experienced Frontend Folks - New Blog Post at FrontendGeek.com ✅ setTimeout polyfill implementation in JavaScript Here is the post link - https://lnkd.in/di7iVSiT 🚀 What's hard in the setTimeout polyfill implementation Most of the frontend candidates approach this question using while loops to track the time, but that is not an efficient approach to implement this question because while loops are blocking in nature and freeze the application You should be familiar with "requestAnimationFrame" to implement this polyfill. Check out at MDN - https://lnkd.in/d9YSJG7f ⬇️ Comment down if you have encountered any tricky polyfill questions in your interview. --- ✅ Check out FrontendGeek.com to prepare for all rounds of Frontend Interviews with the best curated resources for free.   🚀 Follow Anuj Sharma & FrontendGeek to stay tuned with Frontend Interview preparation tips, development & jobs-related stuff #frontend #interview #frontendinterview #javascript #js #polyfill #questions #react #preparation #javascriptinterview #frontendgeek

101

15 Comments

PayPal Joins Hands with NPCI to Take India’s UPI Global 🌍 India’s homegrown payment system is officially stepping onto the world stage. In a major leap for cross-border digital payments, PayPal has partnered with NPCI International Payments Limited (NIPL) to bring India’s Unified Payments Interface (UPI) to PayPal World—PayPal’s newly launched global payments platform. Announced in July 2025, PayPal World connects some of the world’s largest digital wallets under one ecosystem—PayPal, Venmo (US), Tenpay Global (China), Mercado Pago (Latin America), and now UPI (India)—together representing nearly 2 billion users worldwide. So what does this mean in real life? 👉 Indian users can now pay international merchants using UPI, starting with select PayPal merchants in the US. No cards. No confusing forex steps. No new apps. Just the same UPI experience—fast, familiar, and real-time—now working beyond India’s borders. Ritesh Shukla, MD & CEO of NIPL, summed it up well: “This integration marks a major milestone in expanding UPI’s global footprint and aligns with our vision of seamless, secure, and inclusive cross-border payments.” For global merchants, this is huge. It opens access to hundreds of millions of UPI users in India, reduces checkout friction, and makes cross-border e-commerce more inclusive. PayPal CEO Alex Chriss has also highlighted that UPI is the first payment system partner on PayPal World—a strong signal of India’s leadership in real-time digital payments and its influence on global standards. This isn’t just a technical integration. It’s a statement. India’s fintech innovation—once focused on domestic payments—is now exporting simplicity, speed, and scale to the global economy. 🚀 Will this accelerate global adoption of UPI-like systems? 💸 How do you see this impacting cross-border e-commerce and remittances? The future of global payments just got a little more Indian 🇮🇳 #UPI #FinTech #DigitalPayments #IndiaTech #CrossBorderPayments #PayPal #paytm

84

I have been taking interviews for backend engineers (5–12 yrs exp) for some time now. Just sharing few common patterns I keep noticing. 1. Too much focus on buzzwords Microservices, Kafka, Redis, System Design… all good. But when I go little deeper into basics (collections, threads, DB transactions), answers become shaky. Strong foundation still matters a lot. 2. Not able to explain their own project properly When I ask “Can you explain your current system architecture?” Many give very high-level answers. If you worked on something daily, you should be able to draw and explain it clearly. 3. No discussion about trade-offs At senior level, I expect thinking like: Why this approach? Why not something else? What are the pros/cons? There is no perfect design. Only better decisions for a given situation. 4. Random debugging approach If production issue comes, how will you approach? Some candidates jump directly to guessing. I look more for structured thinking than instant solution. 5. Communication at senior level After 8+ years, it’s not just coding. It’s ownership, clarity, mentoring ability and confidence in decision making. Just sharing observations. If you are preparing for interviews, focus on fundamentals + clarity of thought. Would love to hear what others have noticed.

356

18 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

An index is not magic. It is a tax. When a query is slow, the knee-jerk reaction is to “add an index.” It fixes the read speed immediately. Ticket closed. But six months later, your database CPU is pegged at 90%. Your disk usage has ballooned. Your insert latency has tripled. Why? Because nobody considered the Physics of Data. In this week’s deep dive, we analyze why B-Trees (the engine behind Postgres and MySQL) collapse under write-heavy loads. Here is the math: When you INSERT a row into a table with 5 indexes, you aren’t doing 1 write. You are doing 6 writes (1 to the Heap + 5 to the Indexes). You have amplified your I/O by 600%. But the real killer is Random Writes. If you are using UUID v4 as your Primary Key, you are fighting against the B-Tree architecture. • The Mechanism: B-Trees love order. Random UUIDs force the database to insert data into the middle of old, full pages. • The Cost: This triggers “Page Splits” and “Random Seeks,” forcing the database to fetch cold pages from the disk into RAM. • The Result: A 15x degradation in performance. We review a real-world case study where switching from UUID to Sequential IDs dropped latency from 180ms to 12ms. Stop treating your database like a black box. Understand the metal. Read the full breakdown of B-Trees vs. Random Writes here. ⬇️ Link in the first comment. #SystemDesign #Database #SQL #Postgres #SoftwareEngineering #Architecture #TechDebt

𝗧𝗵𝗲 𝗖𝗮𝗿𝗲 𝗮𝗻𝗱 𝗙𝗲𝗲𝗱𝗶𝗻𝗴 𝗼𝗳 𝘆𝗼𝘂𝗿 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗮𝗹 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿. 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

𝗠𝗼𝘀𝘁 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗼𝘂𝘁𝗮𝗴𝗲𝘀 𝗱𝗼𝗻’𝘁 𝘀𝘁𝗮𝗿𝘁 𝗶𝗻 𝘁𝗵𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲. 𝗧𝗵𝗲𝘆 𝘀𝘁𝗮𝗿𝘁 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗮𝘀𝘀𝘂𝗺𝗽𝘁𝗶𝗼𝗻𝘀 𝗮𝗿𝗼𝘂𝗻𝗱 𝗶𝘁. 1. Unbounded queries. 2. Missing indexes. 3. APIs treat the DB like a debug console. AI-generated code that “works”… but doesn’t scale. In FinTech, a 10𝗺𝘀 𝘀𝗹𝗼𝘄𝗱𝗼𝘄𝗻 quietly becomes a 10-𝗺𝗶𝗻𝘂𝘁𝗲 𝗶𝗻𝗰𝗶𝗱𝗲𝗻𝘁. 👉 What’s one database mistake you have seen take down an otherwise healthy system?

10

1 Comment

🚀 How to Crack Bigger Offers 1️⃣ Set a Target Role & Compensation → Clarity helps you reverse-engineer your preparation. 2️⃣ Deep Preparation, Not Random → Focus on core fundamentals (DSA, System Design, Domain Skills) instead of scattered online content. 3️⃣ Mock, Mock, Mock → Regularly test yourself with mocks, peers, or mentors to identify gaps early. 4️⃣ Time-Bound Learning → Prepare with deadlines. Infinite preparation is a trap. 5️⃣ Show Proof of Work → Build side projects, publish blogs, contribute to open-source, or showcase innovations. 6️⃣ Strategic Networking → Referrals and connections often open doors faster than applications. 7️⃣ Master Communication → Big offers don’t just depend on solving problems, but how clearly you explain solutions. 8️⃣ Negotiate Smartly → Research market standards, know your worth, and negotiate with confidence. 9️⃣ Stay Consistent & Resilient → Failures are feedback. Iterate until you succeed. 💡 Remember: Bigger offers come when you create bigger impact.

29