Shrinath Balakrishnan

35 practical thoughts on system design Core Principles 1. Every system is a trade-off -> you never get speed, cost, and simplicity all at once. 2. Latency compounds -> every millisecond added across layers adds up to user pain. 3. Scalability ≠ performance -> one handles growth, the other handles speed. 4. Read vs. write paths -> scaling each requires completely different strategies. 5. Design for change, not perfection -> requirements will shift. Databases & Storage 6. Indexes are levers -> high-selectivity columns are worth indexing, low ones often aren’t. 7. Replication helps reads, partitioning helps writes -> don’t confuse the two. 8. Dual writes are a lie -> without coordination, you will see drift. 9. Event stores > queues (sometimes) -> better traceability, worse simplicity. 10. Cache invalidation is still the hardest problem -> freshness vs. performance is the eternal fight. Reliability & Consistency 11. Idempotency saves you -> retries without it will hurt. 12. Fail fast, fail loud -> silent failures sink systems. 13. Eventual consistency is a feature -> not a bug, but only if the business allows it. 14. Conflict resolution in active-active is business logic, not infra. 15. Durability isn’t free -> syncing across regions has cost and latency. Architecture Patterns 16. Microservices are an org structure, not a tech goal. 17. Monolith first, modular second, microservices last -> don’t jump too early. 18. Choreography scales, orchestration simplifies -> pick based on team maturity. 19. Serverless buys you focus, costs you control. 20. Queues don’t remove work, they smooth it. Observability & Operations 21. Tracing > logging -> logs tell you “what”, traces tell you “why”. 22. Metrics rot without ownership -> measure what someone actually uses. 23. Retries without backoff = DDoS on yourself. 24. Dead-letter queues aren’t optional -> every system has poison messages. 25. Levers > knobs -> design quick kill switches and controls to contain blast radius. Performance & Cost 26. Optimize the hot path, not the cold path. 27. Most bottlenecks live in the database, not the code. 28. Horizontal scaling beats vertical scaling ->until coordination kills it. 29. Warm caches mask bad queries -> measure against cold starts too. 30. The cheapest resource is disk, the most expensive is time. People & Process 31. The best architecture dies without documentation. 32. System design reviews aren’t about diagrams, they’re about trade-offs. 33. Small PRs are for speed, big PRs are for context -> balance both. 34. A senior engineer’s role in design is asking the uncomfortable “what if”. 35. No design survives first contact with production -> but good ones bend instead of break. Want to sharpen your instincts with daily practice? Check out joinenginuity.com One system design question every day, with streaks, badges, and leaderboards, and a dashboard to keep you sharp. Enjoy the rabbit hole!

1,463

93 Comments

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

📌 𝗥𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝘁𝗲𝘀𝘁𝗶𝗻𝗴 𝗶𝘀 𝗮𝘀 𝗲𝘀𝘀𝗲𝗻𝘁𝗶𝗮𝗹 𝗮𝘀 𝗿𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝗰𝗼𝗱𝗲. At Zepto, we kept hitting a wall with 𝘁𝗵𝗶𝗿𝗱-𝗽𝗮𝗿𝘁𝘆 𝗔𝗣𝗜 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝗿𝘀' 𝘀𝗮𝗻𝗱𝗯𝗼𝘅𝗲𝘀 that were slow, unreliable, or simply unavailable - 𝗯𝗹𝗼𝗰𝗸𝗶𝗻𝗴 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 𝗮𝗻𝗱 𝘄𝗮𝘀𝘁𝗶𝗻𝗴 𝘃𝗮𝗹𝘂𝗮𝗯𝗹𝗲 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗵𝗼𝘂𝗿𝘀. So we built our own: 𝗨𝗻𝗶𝘃𝗲𝗿𝘀𝗮𝗹 𝗠𝗼𝗰𝗸 𝗦𝗲𝗿𝘃𝗶𝗰𝗲 🚀 A self-hosted simulation engine for 𝗛𝗧𝗧𝗣, 𝗴𝗥𝗣𝗖, 𝗞𝗮𝗳𝗸𝗮 & 𝘄𝗲𝗯𝗵𝗼𝗼𝗸𝘀 that lets teams:  • Mock without writing code  • Proxy + mock selectively for hybrid testing  • Record & replay real responses  • Simulate event-driven workflows The outcome? 𝗥𝗲𝘀𝗶𝗹𝗶𝗲𝗻𝘁 𝘁𝗲𝘀𝘁 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁𝘀, 𝗳𝗮𝘀𝘁𝗲𝗿 𝗤𝗔, 𝗮𝗻𝗱 𝘀𝗶𝗴𝗻𝗶𝗳𝗶𝗰𝗮𝗻𝘁 𝗯𝗮𝗻𝗱𝘄𝗶𝗱𝘁𝗵 𝘀𝗮𝘃𝗶𝗻𝗴𝘀 - while giving teams complete control over their testing ecosystem. Rich, one of our rockstar Engineering Managers, has detailed it in one of our latest Tech Blogs. The link is in the first comment. #ZeptoTechXPress

302

16 Comments

🎯 Frontend Development Skills for Product-Based Companies 🔥 Ready to stand out in top tech teams? Join Ng Delhi Community: https://lnkd.in/gZfR9exS ✅ A well-structured roadmap is your best friend if you’re aiming to become a high-performing frontend developer. 📌 𝗕𝗮𝘀𝗶𝗰 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀 • Data types • Functions • Scope • Closures • Event loop • Prototype & prototype chain • Classes & inheritance • DOM manipulation • bind / call / apply • Promises • Web APIs • Task queue & call stack • Async/await • Generators • TypeScript 📌 𝗕𝗮𝘀𝗶𝗰 𝗛𝗧𝗠𝗟 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀 • Block vs Inline elements • Semantic HTML • Imports and includes • Forms & accessibility • Infinite questions, infinite possibilities! 📌 𝗕𝗮𝘀𝗶𝗰 𝗖𝗦𝗦 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀 • Selectors (Class, ID, Universal) • Pseudo Classes & Elements • Box Model • Display types: flex, grid, block • Centering techniques • Element states: active, hover, focus • Media queries • Preprocessors: SCSS/LESS • Mixins, variables, constants • BEM naming convention • Importing styles 📌 𝗕𝗮𝘀𝗶𝗰 𝗪𝗲𝗯 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀 • Page rendering lifecycle • HTTP, HTTPS, HTTP/2 • CORS • LocalStorage / SessionStorage • Cookies • JWT • XMLHttpRequest • Micro Frontends • REST / GraphQL / WebSocket • Browser internals • Debugging techniques • Chrome DevTools mastery 📌 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 • OOP principles • Design Patterns: ▸ Singleton, Provider, Prototype ▸ Observer, Module, HOC • V8 Engine insights: ▸ JIT, Interpreter, Execution • Currying 📌 𝗕𝗮𝘀𝗶𝗰 𝗥𝗲𝗮𝗰𝘁𝗝𝗦 (𝗕𝗼𝗻𝘂𝘀) • JSX • Components (Functional & Class) • State, Props, Hooks • Lifecycle methods • Virtual DOM • Context API • Redux / Flux • Routing • Testing with Jest & RTL • Webpack, Babel, ESLint, Prettier 📌 𝗕𝗮𝘀𝗶𝗰 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 (𝗕𝗼𝗻𝘂𝘀) • Angular architecture & modules • Components, Directives, Pipes • Services & Dependency Injection • Lifecycle Hooks • Routing & Lazy Loading • Template vs Reactive Forms • RxJS & Observables • Change Detection Strategies • Angular Signals (latest) • State Management (NgRx / Signals) • Testing with Jasmine & Karma • Angular CLI, Environment configs • SSR with Angular Universal • Angular Material & CDK Like, save, and share if this helped you! Enjoy learning — one topic at a time! #frontend #javascript #html #css #webdevelopment #reactjs #angular #typescript #roadmap #developers #ngdelhi #codingjourney #techskills

110

4 Comments

Transactions are a protocol on top of a storage layer. It might be integrated into the storage layer. But you can also always build your own transaction layer on top of a storage layer that doesn't support transactions. You can also even ignore the transaction layer of any storage layer that has an integrated transaction layer and build your own transaction layer on top. Convex did this, reimplementing MVCC on top of Postgres (or MySQL or something). And the Delta Lake protocol for transactions on blob storage is even simpler.

83

4 Comments

If I were your interviewer in a System Design interview, here’s how I’d evaluate your answers — based on these 40 core fundamentals: 1. Scalability – Vertical vs horizontal; default to stateless horizontal scale 2. Latency & Throughput – Know P50/P95/P99 and tradeoffs 3. Capacity Estimation – Estimate QPS, storage, bandwidth 4. Networking Basics – TCP, HTTP/HTTPS, TLS, UDP, DNS 5. SQL vs NoSQL – Decide by access patterns, joins, consistency 6. Data Modeling – Structure to optimize hot queries 7. Indexing – Right indexes help reads, wrong ones hurt writes 8. Normalization – Normalize for writes, denormalize for reads 9. Caching – App/DB/CDN; write-through/back, TTLs 10. Cache Invalidation – TTLs, versioning, stampede protection 11. Load Balancing – L4/L7, RR, least-connections, hashing 12. CDN & Edge – Serve static content near users 13. Sharding – Hash/range/geo; handle hot keys, rebalancing 14. Replication – Sync/async, leader/follower, read replicas 15. Consistency Models – Strong, eventual, causal 16. CAP Theorem – In partition, pick A or C 17. Concurrency – Locks, MVCC, retries 18. Multithreading – Pools, contention, switching 19. Idempotency – Same request, same effect 20. Rate Limiting – Fairness and protection 21. Queues & Streams – Kafka, RabbitMQ; smooth spikes 22. Backpressure – Manage slow consumers/load shedding 23. Delivery Semantics – At-most/least/exactly-once 24. API Design – REST vs gRPC; human vs machine optimized 25. API Versioning – Additive only; never break clients 26. AuthN & AuthZ – OAuth2, JWT, RBAC/ABAC 27. Resilience – Circuit breakers, timeouts, retries 28. Observability – Logs, metrics, traces, SLI/SLO 29. Health Checks – Detect failures, auto-replace 30. Redundancy – Avoid SPOFs; use multi-AZ/region 31. Service Discovery – Dynamic endpoints, central config 32. Deployment – Canary, blue/green, rollbacks 33. Monolith vs Microservices – Split only if ops cost justified 34. Distributed Transactions – Use sagas, avoid 2PC 35. Event Sourcing/CQRS – Append-only logs, split models 36. Consensus – Raft, Paxos, quorum reads/writes 37. Data Privacy – Encryption, GDPR/CCPA 38. Disaster Recovery – Backups, RPO/RTO, test it 39. Serialization – JSON, Avro, Proto 40. Real-Time Delivery – Polling, SSE, WebSockets 📌Comment “Fundamentals” if you want access to this mindmap, I’ll send it you in the comments!!

997

146 Comments

Designing Scalable Systems – One Service at a Time! Over the past few days, my friends Nikhil Gautam, Harsh Bhadouria, Akshat Kabra, Harsh Yadav and I have been working on the High-Level Design (HLD) of a microservices-based architecture for a real-time booking flight system. 🛫📦 We explored: Kafka-based event-driven communication 🎯 Microservices for Booking, User, Search/Fare, and Notification 🔧 Redis caching for fast fare lookups ⚡ Worker queues for retry mechanisms (Email/SMS/Push) 🔁 A central API Gateway for routing, auth, and request management 🧩 Plans to integrate a Payment Service for transaction handling 💳 This exercise really helped us understand how different services interact, how to design for resilience, and why asynchronous processing is key at scale. 💡 Key Takeaway: Good architecture is not just about handling success paths — it’s about gracefully handling failures too. If you're working on something similar or want to collaborate on system design projects, let’s connect! 🔗 #SystemDesign #Microservices #Kafka #Architecture #Engineering #Backend #Scalability #TechLearning #SoftwareEngineering #APIGateway

208

16 Comments

𝗟𝗟𝗠 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗶𝗼𝗻 𝘁𝗼 𝗼𝘂𝗿 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝘁𝘂𝗿𝗻𝗲𝗱 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝗶𝗻𝘁𝗼 𝗮 𝗻𝗶𝗴𝗵𝘁𝗺𝗮𝗿𝗲. 𝗛𝗲𝗿𝗲'𝘀 𝗵𝗼𝘄 𝘄𝗲 𝗳𝗶𝘅𝗲𝗱 𝗶𝘁 𝗶𝗻 𝟱 𝗱𝗮𝘆𝘀 𝘄𝗶𝘁𝗵 𝘇𝗲𝗿𝗼 𝗻𝗲𝘄 𝘁𝗼𝗼𝗹𝘀. 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: A single user request triggers 200+ LLM calls. Which one failed? Where did context break? Our MTTR became as high as 7 hours. As a Startup, we cannot afford to have our reputation at stake. 𝗧𝗵𝗲 𝗦𝘁𝗮𝗿𝘁𝘂𝗽 𝗗𝗶𝗹𝗲𝗺𝗺𝗮: Everyone suggested: LangSmith, LangFuse, Helicone. - Evaluating tools = 2-3 weeks - Every new tool = Learning curve + cost + vendor management - We don't even know what we need yet 𝗙𝗶𝗿𝘀𝘁 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀: What exactly do we need to debug? Input sent, response received, post-processing results, and relationships between 200+ calls. The insight: Not a logging problem. It's a 𝘁𝗿𝗮𝗰𝗶𝗻𝗴 𝗽𝗿𝗼𝗯𝗹𝗲𝗺. Each LLM call is stateless. Our application maintains context. Same applies to observability. 𝗧𝗵𝗲 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: We already had Grafana Loki, Tempo, and OpenTelemetry. The breakthrough: Connect all LLM calls under one parent span. 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 (𝗿𝗲𝗳𝗲𝗿 𝗱𝗶𝗮𝗴𝗿𝗮𝗺): 𝟭. 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗟𝗮𝘆𝗲𝗿 OpenTelemetry emits logs and traces 𝟮. 𝗟𝗼𝗴𝘀 (𝗚𝗿𝗮𝗳𝗮𝗻𝗮 𝗟𝗼𝗸𝗶) Captures each LLM interaction: - trace_id & span_id - Message sent & response received 𝟯. 𝗧𝗿𝗮𝗰𝗲𝘀 (𝗚𝗿𝗮𝗳𝗮𝗻𝗮 𝗧𝗲𝗺𝗽𝗼) Parent span connects all related calls: - "Analyze PDF" → Factor 1 (Profit) → Factor 10 - Each factor → LLM Call 1... Call 20 Shows serial vs parallel execution, timing 𝟰. 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗨𝗜 (𝗚𝗿𝗮𝗳𝗮𝗻𝗮) Query by span_id → Complete journey with all logs 𝗧𝗵𝗲 𝗥𝗲𝘀𝘂𝗹𝘁𝘀: - MTTR: 7 hours → 30 minutes - Timeline: 5 days(2 design + 2 dev + 1 infra) - Cost: $0 in new tools - Complexity: Zero new vendors 𝗞𝗲𝘆 𝗗𝗲𝘀𝗶𝗴𝗻 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀: 𝗪𝗵𝘆 𝗧𝗿𝗮𝗰𝗲𝘀 𝗢𝘃𝗲𝗿 𝗟𝗼𝗴𝘀? Logs show events. Traces show relationships. For 200+ interconnected calls, relationships matter. 𝗪𝗵𝘆 𝗘𝘅𝗶𝘀𝘁𝗶𝗻𝗴 𝗦𝘁𝗮𝗰𝗸 𝗢𝘃𝗲𝗿 𝗡𝗲𝘄 𝗧𝗼𝗼𝗹𝘀? Existing stack solved 80%. New tools solve 100% but cost 5x in time, money, and complexity. 𝗪𝗵𝘆 𝗣𝗮𝗿𝗲𝗻𝘁-𝗖𝗵𝗶𝗹𝗱 𝗦𝗽𝗮𝗻𝘀? Mirrors how our application maintains state. One request → Multiple factors → Multiple LLM calls. 𝗦𝘁𝗮𝗿𝘁𝘂𝗽 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗟𝗲𝘀𝘀𝗼𝗻𝘀: Don't: Add new tools before understanding the problem Do: Define what you need first (saved 3 weeks) Don't: Evaluate 5 tools when you don't know what you need Do: Use existing stack, learn what's missing, choose deliberately Don't: Wait for the "perfect" solution Do: Ship 80% solution in 5 days, iterate based on production issues We'll eventually need specialized AI observability tools. But not today. Tomorrow, we'll know exactly which tool solves which problem. That's 𝗦𝘁𝗮𝗿𝘁𝘂𝗽 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴: Choose simple over perfect solution. Solve for 80%. Iterate to 100%.

24

2 Comments