Manoranjan Behura

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

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

📌 𝗥𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝘁𝗲𝘀𝘁𝗶𝗻𝗴 𝗶𝘀 𝗮𝘀 𝗲𝘀𝘀𝗲𝗻𝘁𝗶𝗮𝗹 𝗮𝘀 𝗿𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝗰𝗼𝗱𝗲. 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

🔥Kafka can handle 2+ MILLION messages per second, but it's overkill for 90% of applications - ZeroMQ has ZERO broker overhead it's just a library that makes our app lightning fast. - RabbitMQ's routing capabilities are so advanced, we can build entire microservice orchestration with just message patterns. - Redis Streams gives us Kafka-like features at a fraction of the complexity. - Amazon SQS costs more but saves weeks of infrastructure headaches. - ActiveMQ has been quietly powering enterprise systems for 20+ years. The Real Question: Are we choosing based on hype or actual requirements???☺️ Connect Sabari Balaji for Tech Insights 💡

250

10 Comments

How API Gateways work (explained in 2 mins or less): An API gateway acts as a single entry point for clients, handling request routing, response composition, and protocol translation. It simplifies client interactions with microservices and offers additional features like rate limiting, authentication, monitoring, and more. To better understand how an API gateway works, let's look at how it processes a request: 𝟭) 𝗜𝗻𝗶𝘁𝗶𝗮𝗹 𝗿𝗲𝗾𝘂𝗲𝘀𝘁 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 ↳ Client requests are sent to the API gateway, which acts as the entry point for all incoming API traffic, rather than directly accessing the backend services. 𝟮) 𝗥𝗲𝗾𝘂𝗲𝘀𝘁 𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 ↳ The API gateway processes and validates the request’s attributes to ensure it’s correctly formatted. 𝟯) 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆 𝗰𝗵𝗲𝗰𝗸𝘀 ↳ It then performs checks against allow-lists and deny-lists to filter out unauthorized or harmful requests. 𝟰) 𝗔𝘂𝘁𝗵𝗲𝗻𝘁𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 𝗮𝘂𝘁𝗵𝗼𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 ↳ The API gateway validates the request, checking for proper authentication (e.g., verifying tokens or credentials) and ensuring the client has the necessary permissions (authorization) to access the requested resources. 𝟱) 𝗥𝗮𝘁𝗲 𝗹𝗶𝗺𝗶𝘁𝗶𝗻𝗴 ↳ Rate limiting rules are enforced; if the request exceeds the allowed limit, it’s rejected. 𝟲) 𝗦𝗲𝗿𝘃𝗶𝗰𝗲 𝗱𝗶𝘀𝗰𝗼𝘃𝗲𝗿𝘆 𝗮𝗻𝗱 𝗿𝗼𝘂𝘁𝗶𝗻𝗴 ↳ Once passing basic checks, the API gateway then finds the relevant service to route the request to by matching the path. 𝟳) 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝘁𝗿𝗮𝗻𝘀𝗹𝗮𝘁𝗶𝗼𝗻 ↳ The API gateway transforms the request into the appropriate protocol and sends it to the service. 𝟴) 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗲 𝗮𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻 ↳ If the request requires data from multiple services, the API gateway aggregates the responses. It sends requests to each relevant service, collects the results, and composes them into a single, cohesive response. 𝟵) 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗲 𝗱𝗲𝗹𝗶𝘃𝗲𝗿𝘆 ↳ The gateway sends the processed response back to the client, ensuring it’s delivered in the expected format and within an optimal timeframe. 𝟭𝟬) 𝗟𝗼𝗴𝗴𝗶𝗻𝗴, 𝗺𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴, 𝗳𝗮𝘂𝗹𝘁 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴, 𝗮𝗻𝗱 𝗰𝗮𝗰𝗵𝗶𝗻𝗴 ↳ Throughout this process, the API gateway logs each request and response and monitors key metrics such as latency, error rates, and throughput. These logs and metrics help in troubleshooting, scaling, & optimizing the system. It also deals with faults (circuit break), & provides response caching. An API gateway is a powerful tool that not only simplifies client interactions with microservices but also enhances security, performance, & reliability through comprehensive request processing & monitoring. ~~ Thanks to our partner CodeRabbit who keeps our content free to the community. They're providing unlimited 𝗳𝗿𝗲𝗲 𝗔𝗜 𝗰𝗼𝗱𝗲 𝗿𝗲𝘃𝗶𝗲𝘄𝘀 directly 𝗶𝗻 𝘁𝗵𝗲 𝗜𝗗𝗘. (rate limits apply). Try out the VS Code extension (it's free): https://lnkd.in/gU7NQGTc

546

18 Comments

Ever faced issues with rollback hell in distributed systems? When services like Order → Inventory → Payment are tightly coupled in a synchronous flow, a single failure can break the entire transaction chain. Add in retry logic, rollbacks, and partial failures, and you're suddenly dealing with a fragile, monolithic-like setup inside a microservices world. Thankfully we have Saga Pattern: a better way to handle distributed transactions. In my latest video, I break down: ✅ Why traditional transaction models don’t scale in microservices ✅ How Saga Orchestration and Choreography work ✅ Step-by-step compensation logic for failures ✅ Comparison with 2-Phase Commit ✅ When to use which approach ✅ What’s next: a Spring Boot + Kafka implementation demo If you're building resilient, scalable systems, this one's for you. 📺 Watch now 👉 https://lnkd.in/gX2bdy86 How are you handling distributed transactions in your architecture? #Microservices #SagaPattern #DistributedTransactions #SystemDesign #Kafka #SpringBoot #SoftwareArchitecture #DevTalk #LazyProgrammer

113

22 Comments

Spinner froze post "Confirm Purchase" Second click could mean double charges and duplicate orders, wonder if I should click it again? Solution: Idempotent APIs What makes an API idempotent? 1. Multiple identical requests produce the same result as a single request 2. System state remains unchanged after the first successful operation 3. Safe to retry without unintended side effects Key benefits for your distributed architecture: 1. Prevent duplicate operations — No more double charges or repeated actions 2. Ensure consistent results, even if the same request is sent multiple times 3. Simplify error handling by making retries safe and predictable 4. Boost system reliability and user trust by avoiding unintended side effects 5. Enhance fault tolerance, allowing systems to recover gracefully from failures 6. Reduce client-side complexity - Developers can focus on features, not defensive code 🤔 over to you, how to implement idempotent APIs? Let me know in the comments! 👇 --- You've got System Design skills but showcasing them in 60 minutes interview is a completely different challenge for e.g. where to start? How much time to spend on HLD vs LLD etc Let me share a FREE 7-day email course that provides a step-by-step framework for acing your 60-minute System Design interview 📣 Sign up for the course at systemdesign.engineer, to learn time allocation to demonstrate full range of design skills

56

11 Comments

Eating the exception poisoning the app!, Handling the errors properly and propagates the exception/logical error to the controller or the use case, will be too helpful to write a robust logic and handles any case in a proper way. We have 2 options. 1. Use Result<T> This is too helpful class holds the data or exception, and it's part of kotlin standard library (so it's too stable), but the limitation is, it only propagates the T or exception, not other errors, and if you uses when statement you will be forced to use else. Something like .onSuccess { user -> println(user.name) } .onFailure { error -> when (error) { is NetworkException -> println("Failed to fetch user") is ParsingException -> println("Failed to parse user") else -> println("Unhandled error") } } 2. Use Either<T, E> This is the best solution (until kotlin 2.4 released!) return type will be either data T, or Error E, and this error could be a sealed class, which means it will be exhaustive when, and it's functional, which means you can flatmap and mapLeft and much more (Documentation link https://lnkd.in/dTQ_qdVd) Note: In kotlin conf 2025, there are an announcement for kotlin 2.4 for new class types called error and the union type only for Rich errors, something like error class NetworkError error class ParsingError fun getUser(): User | NetworkError | ParsingError Happy coding 😄 #kotlin #android #kmp #cmp #software_engineering

144

9 Comments

** Razorpay Frontend Interview Experience for Senior Engineer Role ** 🧩 Round 1: Technical + Project Deep Dive Discussion around past projects, component libraries, and performance optimizations. Also discussions around Micro Frontends using Module Federation and the trade-offs compared to monolithic builds. Takeaway: Don’t just explain what you built — explain why you made those decisions and what impact they had. ⚙️ Round 2: Core JavaScript A deep dive into language fundamentals — event loop, closures, inheritance, type coercion — followed by polyfill implementations like Promise.all and debounce. Discussion around memory leaks, useEffect cleanup patterns, and performance best practices. Takeaway: Know your JavaScript deeply. Writing a polyfill is often the best way to prove understanding. ⚛️ Round 3: Machine Coding (React) This was a hands-on session to build a solution from a given problem statement. Takeaway: Razorpay values precision. Even small misses in validation or async flow can make the difference. If you want to learn about more questions asked by Razorpay, try: https://lnkd.in/d2rA9teT -- Follow Mansi Gupta and Devtools Tech for more.

183

3 Comments

REST is mature. GraphQL is flexible. But which one scales with your product vision? 𝗥𝗘𝗦𝗧 𝘃𝘀 𝗚𝗿𝗮𝗽𝗵𝗤𝗟: 𝗖𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝘁𝗵𝗲 𝗥𝗶𝗴𝗵𝘁 𝗧𝗼𝗼𝗹 𝗳𝗼𝗿 𝗬𝗼𝘂𝗿 𝗔𝗣𝗜 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆 In the world of APIs, REST has been one of the most popular software arhitectural style for more than a decade, it is simple, stateless, and widely adopted. However it is not suited for every situation. As frontend complexity grows and client demands get more dynamic, REST’s rigid structure starts to show its limitations. Have you ever struggled with data being over-fetched or under-fetched ? Or the hassle of managing a growing number of endpoints just to serve different client needs? Enter GraphQL to the rescue, it is a query language that flips the script. Instead of the server dictating what data is returned, the client gets to ask for exactly what it wants. Fewer requests. Lighter payloads. Smarter interactions. But GraphQL isn’t always the better choice. On one hand REST is mature, it is cache-friendly, and it’s often simple to scale and secure in case of REST architecture. On the other hand GraphQL offers flexibility but can also introduce complexity in performance tuning and authorization. So which one’s right for your stack? In short, Choosing between REST and GraphQL really depends on your app’s needs for performance, simplicity, and data control.  #RESTvsGraphQL #API #WebDevelopment #GraphQL #SoftwareArchitecture #systemdesign #coding

48

20 Comments