Viraj Thakur

It was 8:42 PM at the Amazon office when Priya, a senior engineer, noticed a Slack message from Raj, the newest backend SDE on her team. “Hi Priya, the orders API endpoint you own is suddenly returning 503s after my changes. Could you help me debug? Sorry for the late message.” Priya hesitated for a second. She’d spent months refining that endpoint, handling edge cases, scaling for Prime Day traffic, even documenting the entire flow for new team members. She remembered her own early days, when breaking something felt terrifying, and the seniors weren’t always patient. For a split second, Priya wanted to reply, “It was working fine earlier. Did you check the wiki?” But she didn’t. She joined the call. Raj was clearly stressed, walking through his recent commits. First month at Amazon, production issue, and it was late. Priya listened, asked focused questions, and together they tracked down a missing API key in the environment config. Raj sighed, “Thank you, Priya. Didn’t mean to break anything, just trying to add new promo logic.” Priya replied, “No worries. Bugs happen to all of us. What matters is catching them fast. I’d always rather have a teammate who asks for help than one who hides a problem.” The next morning, Priya shared a quick note in the team channel: > “Thanks to Raj for surfacing the issue quickly and collaborating on the fix. These things happen, what counts is how we respond.” And as she updated her notes, Priya reflected: → Being smart is good but being reliable, calm, and collaborative under pressure is what builds trust. → The most critical projects rarely go to the “lone genius.” They go to the person the team can depend on, day after day. Over time, more teammates started coming to Priya for tricky launches, because she was steady, approachable, and always showed up when it mattered. Because in the long run, that’s what makes you the engineer everyone trusts to deliver. And that’s the reputation that really opens doors.

4,001

102 Comments

CDC comes up a lot in system design interviews. It solves the very real problem of propagating database changes to other systems without constant polling. But what happens when your interviewer decides to probe into implementation? Do you really understand how it works? Most candidates I see can parrot the basics - "CDC captures database changes in real-time" - but they fall apart when asked how it actually works. Let's see how this is done using Postgres as an example. PostgreSQL already logs every transaction to its Write-Ahead Log for crash recovery. Logical decoding (PostgreSQL's feature that converts raw WAL changes into structured, readable events) reads these WAL entries and converts them into structured change events. Debezium is a popular open-source CDC platform that connects to your database and streams these changes to Kafka. When you set up Debezium, it first takes a consistent snapshot of your database, then immediately starts streaming from the exact WAL position where that snapshot ended. The timing eliminates race conditions and missing data between the snapshot and the stream. Logical replication slots make this reliable. PostgreSQL holds onto WAL segments until your CDC consumer confirms it processed them. Your Debezium connector can crash, get redeployed, or go offline for hours, but when it comes back, it resumes from the last confirmed LSN offset. Debezium transforms these WAL entries into standardized change events and pushes them to Kafka. Each event includes the LSN for ordering guarantees. Your downstream systems - search indexes, caches, analytics - consume these events and stay synchronized without ever polling the primary database. The best part is the performance impact is minimal because you're getting a free ride on PostgreSQL's existing durability guarantees. The WAL exists regardless of whether you're using CDC. Once you understand the WAL + logical decoding combo, CDC stops feeling like black magic.

842

32 Comments

If you want to become better at system design rounds, definitely read these 10 case studies by Neo Kim. I am 100% sure, they will make you smarter for your next interview.  1/ How Meta Achieves 99.99999999% Cache Consistency: → https://lnkd.in/e88kUZAm 2/ How Uber Computes ETA at Half a Million Requests per Second: → https://lnkd.in/eVKV2ePC 3/ How PayPal Was Able to Support a Billion Transactions per Day With Only 8 Virtual Machines: → https://lnkd.in/eqcb7MpP 4/ How YouTube Was Able to Support 2.49 Billion Users With MySQL: → https://lnkd.in/efmJw4Dx 5/ How WhatsApp Was Able to Support 50 Billion Messages a Day With Only 32 Engineers: → https://lnkd.in/gRqBgXfc 6/ How Uber Finds Nearby Drivers at 1 Million Requests per Second: → https://lnkd.in/eeqH9Hjh 7/ How Stripe Prevents Double Payment Using Idempotent API: → https://lnkd.in/erMkqwq4 8/ How Google Ads Was Able to Support 4.77 Billion Users With a SQL Database: → https://lnkd.in/efnSvwJp 9/ How Amazon S3 Achieves 99.999999999% Durability: → https://lnkd.in/eutGiK35 10/ How Slack Works: → https://lnkd.in/eATMDjrK

249

21 Comments

Engineering blogs are one of the best ways to learn system design, given how practical they are. I have been dissecting engineering blogs for the last 2 years and posting my explainers on YouTube. While going through my history, I realized I now have 53 blog dissections :) If you are interested in digging deeper into the practical nuances of running systems at scale, give it a watch. I break down complex blogs into simple, visual explanations - no fluff, just real-world systems. Each video focuses on the why behind design choices, not just the what. Here's the playlist - https://lnkd.in/gQ95KnKA I also have explainer series on the following - System design (85+ videos) - Hash table internals - BitTorrent internals - Major outage dissections - Database internals and fundamentals That’s over 220 videos total; all no-fluff and highly practical :) Great for backend engineers or anyone curious about how real-world systems actually work. Many more to come.

621

12 Comments

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.

135

23 Comments

Most students know me for competitive programming, but many (except those in AZ Premium) haven’t seen my other side. In the premium classes, I’ve taken multiple sessions on system design—focusing on analyzing trade-offs and solving real-world problems, not just coding challenges. I’ve now started a Placement Series on YouTube. The latest video is on multithreading in system design—covering fundamentals, common pitfalls, and how to reason about concurrency. Watch it to strengthen your design thinking beyond algorithms. #AZ #AZPremium

155

1 Comment

If I had a system design interview tomorrow at Google, this is exactly how I’d approach it. (This framework helped me crack 3 FAANG+ companies in the past, including Amazon.) Most engineers fail system design interviews not because they lack knowledge but because they lack structure. You don’t need to memorize 100 architectures. You need a structured and easy-to-apply approach that works every time. Here’s how I break it down: 1/ Clarify the Problem Before Writing Anything - System design interviews aren’t about throwing buzzwords—they’re about trade-offs. - Start with scoping → Are we designing just one feature or the entire system? - Ask constraints upfront → How many users? Read/write ratio? Latency requirements? - Define success criteria → What matters most? Scalability? Cost? Low-latency? Most candidates assume things and jump into solutions. I make sure I know what we’re solving before I even start. 2/ Define Functional & Non-Functional Requirements Clearly - Functional: What features does the system need? - Non-functional: What are the performance expectations? - What’s the biggest technical challenge? (This helps guide the discussion.) Example: If we’re designing YouTube, is the focus on video uploads, recommendations, or live streaming? Each has a different set of constraints. 3/ Estimate the Scale & Plan Capacity Like an Engineer - Users per second? Requests per second? - Storage needs? If we store 10MB per user and have 100M users, what does that mean? - Throughput? Can a single database handle the load, or do we need sharding? Most candidates throw random numbers. I do quick, back-of-the-envelope calculations to validate my assumptions. 4/ Break the System into Core Components (High-Level Design) - Define the major building blocks → API Gateway, Load Balancer, Service Layers, Databases. - Don’t overcomplicate. Simple and scalable always wins. - Clearly define the interactions between services. If I’m designing a messaging app, I break it down into: — User Service (auth, profiles) — Messaging Service (storing chats) — Notification Service (real-time updates) — Media Storage (for images, videos) Each has different constraints, so I build around what’s most important. Continued Here: https://lnkd.in/eJ2T966N

558

35 Comments

Inside Uber's Engineering Stack Uber runs on real-time logistics at a global scale. Behind every ride request and ETA update lies a powerful, distributed tech architecture. Here’s a snapshot of Uber’s evolving stack built for scale, speed, and flexibility 👇 🔹 Frontend Frameworks -- Fusion.js: Uber’s in-house React framework, optimized for performance and plug-in extensibility. -- Visualization.js: Designed for high-performance geospatial rendering on maps. 🔹 Mobile Architecture -- RIBs Framework: Modular, reactive architecture replacing MVC. -- Languages: Swift for iOS, Java for Android — cross-platform logic with localized UI handling. 🔹 Service Mesh & Communication -- Uber Gateway: Built on NGINX, with dynamic routing and real-time configuration. -- Protocols: gRPC and QUIC for transport, Apache Thrift for cross-service API contracts. 🔹 Service Layer -- Flipr/UCDP: Central config store used across microservices. -- H3: High-res geospatial indexing for location data. -- uAct & Cadence: Event-driven and async orchestration frameworks. -- Spring Boot: Used for most Java-based services. 🔹 Databases & Storage -- DocStore: Uber’s internal OLTP system using MySQL/PostgreSQL with RocksDB for local state. -- Pinot & AresDB: High-speed analytics on time-series and real-time data. -- Alluxio: Memory-speed caching for big data workloads. 🔹 Big Data Stack -- Data Formats: Hudi, Parquet for columnar storage. -- Processing Engines: Apache Hive, Spark. -- Ingestion Layer: Marmaray for batch + stream data ingestion. -- Messaging: Apache Kafka + Flink for event streaming. 🔹 DevOps & Observability -- Monorepo + Devpod: Simplified dev environment for fast iteration. -- CI/CD: Netflix Spinnaker for delivery pipelines. -- Monitoring: uMetric (metrics), uMonitor (alerting), M3 (observability DB). follow Sandeep Bonagiri for more insights

452

10 Comments