Akshit D.

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

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

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

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

RAG is Software Engineering for LLMs. Retrieval = your API layer Indexing = your data modeling Chunking = your pagination logic Embedding = your serialization Vector store = your database Prompt = your query builder Response = your render pipeline We’ve always built systems that fetch, process, and respond. The only thing that changed is what we’re fetching, context instead of data.

615

21 Comments

Software engineers: “I didn’t write any code today.” Also software engineers: constantly checking Slack, hopping between unrelated tickets, several quick syncs, browsing memes, and multiple coffee runs — all before lunch. Let’s be honest. The problem isn’t too much work. It’s work without focus. Every ping, every “quick sync,” every notification is a tax on your brain. You never enter “the zone”. You never solve deep problems. You spend your day context-switching and wonder why no real work got done. Here’s the truth: You don’t need a longer day. You need to guard your time and protect your focus. 5 ways to guard your time as an engineer: 1/ Block 2–3 hours of focus time on your calendar daily. Treat it like a meeting you cannot miss. 2/ Use that time for deep work: design docs, coding, code reviews, or anything that requires real concentration. 3/ Put your phone on Do Not Disturb, close Slack, silence notifications. 4/ Cluster meetings together to preserve larger focus blocks. 5/ Bring your team onboard and advocate for protected engineering time and fewer random interruptions so everyone can deliver results for customers. Deep work isn’t just about productivity. It’s therapy for engineers. It recharges you while you work. It reminds you why you started coding in the first place. And at the end of the day, you’ll leave the office feeling accomplished —not drained. Guard your time. Protect your focus. That’s how you make space to do the work that actually matters. #softwareengineering #focus #productivity

827

55 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

How Big O works (explained in 2 mins or less): ✓ Big O tells how much slower a code gets as the input increases. ✓ There are best, average, and worst cases for a specific algorithm. ✓ Besides there are Big Os for time, memory, and storage efficiency. ✓ Big O helps to understand which data structures or algorithms have better performance. ✓ Big O shows the growth rate and not the actual speed. So it's important to test the input data. What else would you add? —— 👋 PS - Want a fantastic System Design Playbook for free? Join Neo Kim's newsletter with 170K+ software engineers: → https://lnkd.in/e9adXr-U ——— ♻ Repost to help others write good code. 👤 Follow Neo Kim for more.

63

2 Comments

You’re in a backend interview. They ask: "A payment system you designed double–charges some users during high load. How would you debug and fix this?" Here’s how you break it down 👇 1. Reproduce & Trace Simulate high load with stress tests. Enable detailed logs and correlation IDs to trace duplicate requests through the system. 2. Check Idempotency Verify if the API handling payments supports idempotency keys (e.g., unique transaction_id from client). Ensure repeated requests with the same key don’t create multiple charges. 3. Database Transactions & Locks Confirm writes are wrapped in atomic DB transactions. Add row-level locking or optimistic concurrency to prevent race conditions on balance updates. 4. Queueing & Retries Inspect whether retry logic (from clients or workers) is re-processing the same request. Ensure retries are idempotent and queued properly. 5. External Payment Gateway Check if the gateway itself retries or confirms charges multiple times. Use their recommended idempotency headers or reconciliation APIs. 6. Fix & Harden Enforce idempotency tokens at the API boundary. Add deduplication logic at the DB level (unique constraint on transaction reference). Stress-test again to confirm the issue is resolved.

77

8 Comments