Andreas Titus

To cache or not to cache? It’s a daily backend decision. Most engineers cache too much. That’s lazy engineering. Here’s a framework to get it right 1. Is the data accessed frequently? 2. Is it expensive to retrieve? 3. Is it volatile? 4. Is it large? 5. Does it impact user-perceived latency? 6. Is it safe to cache? 7. Do you have a way to expire or invalidate it? I break each down with analogies, visuals, and examples in this new piece: https://lnkd.in/eQKMTyXp For engineers who think in trade-offs.

4.384

204 Komentar

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!!

996

146 Komentar

Trust me, System Design is not HARD. If you follow this 1 Modular Monolith Architecture ↳ https://lnkd.in/edUqkCKR 2 Redis Use Cases ↳ https://lnkd.in/ekJMjMG3 3 Idempotent API ↳ https://lnkd.in/erMkqwq4 4 Saga Design Pattern ↳ https://lnkd.in/eFXC4-aJ 5 How DNS Works ↳ https://lnkd.in/e8H3EGvp 6 How Consistent Hashing Works ↳ https://lnkd.in/eUP9DbCg 7 Service Discovery ↳ https://lnkd.in/eCYYwQfU 8 How API Gateway Works ↳ https://lnkd.in/eMCr9VjE 9 What Happens When You Type a URL Into Your Browser ↳ https://lnkd.in/eusuDn5z 10 Microservices Lessons From Netflix ↳ https://lnkd.in/eZSM3CRB 11 How Websockets Work ↳ https://lnkd.in/euHDJUfH 12 Bloom Filters ↳ https://lnkd.in/e2duES7s 13 How Databases Keep Passwords Securely ↳ https://lnkd.in/edd8-N5k 14 How JWT Works ↳ https://lnkd.in/ek9_BTUc #sde1 #sde2 #sde3 #hiring #systemDesign #layoff #tcs

768

15 Komentar

API design is an important step in any system design interview. You'll need to be able to: 1. Choose the right "API protocol" ie. REST, GraphQL, RPC 2. Follow proper protocol semantics 3. Handle follow up questions about pagination, security, versioning, etc. I'll admit, my bias is that interviewers who are nit-picky here are focused on the wrong things. BUT, that being said, it's easy enough to get right if you know the rules of the game. We recently launched a new deep dive on API Design complete with a YouTube video to match! Let me know what you think :) Article: https://lnkd.in/gih4Wyp3 Video: https://lnkd.in/gy_QNvRG

181

6 Komentar

✔️ Caching Caching to reduce latency and database load, which can significantly improve your application's response times and scalability ✔️ Lazy Loading Lazy Loading: this technique is more than just a delay in loading non-critical modules until needed ✔️ Event Loop Event Loop: This is the heart of Node.js, handling asynchronous operations and ensuring it remains non-blocking, capable of handling multiple tasks concurrently. ✔️Asynchronous - Callbacks, Promises Implement asynchronous programming using callbacks, promises, or async/await to prevent blocking the event loop ✔️ Garbage Collection Optimize garbage collection by managing memory usage and avoiding memory leaks, ensuring smooth application performance ✔️ HTTP/2 and HTTP/3 Upgrade to HTTP/2 or HTTP/3 for better performance through multiplexing, header compression, and reduced latency ✔️ Update and Prune Dependencies Update and prune dependencies regularly to reduce security risks and eliminate unnecessary code, improving performance. ✔️ Fix Memory Leaks Identify and fix memory leaks to prevent excessive memory consumption, which can degrade performance using tools like heap dump and clinic ✔️ Reduce Function Overhead Optimizing function calls and avoiding unnecessary nested functions minimizes function overhead ✔️ Non-Blocking Operations Ensure operations are non-blocking to maintain the event loop's responsiveness and handle concurrent requests efficiently. Use asynchronous APIs to prevent blocking the main thread. ✔️ Mutexes, Semaphores, Locks Implement mutexes, semaphores, and locks to manage resource access and ensure thread safety in concurrent programming ✔️ DB Connection Pool, Indexing, ORM Optimize database interactions by using database connection pooling, indexing, and efficient ORM practices ✔️ Clustering and Scaling Utilize Node.js clustering to distribute the load across multiple CPU cores, enhancing scalability and performance. Implement horizontal scaling to handle increased traffic effectively ✔️ Buffer Pool Manage buffer pools to handle I/O operations efficiently, reducing the overhead of memory allocation and deallocation. Proper buffer management improves data processing speed ✔️ Module Loading Optimize module loading to reduce startup time and memory usage, ensuring faster application initialization ✔️ Compression - Gzip Enable Gzip compression to reduce the size of HTTP responses, improving load times and bandwidth usage ✔️ Tune DB Queries Optimize database queries for better performance, using techniques like indexing, query optimization ✔️ Streams Utilize Node.js streams to process large data sets efficiently. Streams allow memory-efficient data handling ✔️ Nested Callbacks Use promises or async/await to manage asynchronous code and avoid deeply nested callbacks ✔️ Object Pooling and Worker Threads Implement object pooling to reuse objects, reduce memory allocation overhead, and use worker threads for CPU-intensive tasks

86

15 Komentar

No API Gateway? No scale. No security. No control. If you're building microservices or exposing public APIs, this is non-negotiable. Here’s how an API Gateway works behind the scenes and why it’s essential 👇 The 4 Core Layers of an API Gateway 1️⃣ Network Security Layer - Enforces SSL/TLS, shields against DDoS, and applies rate limits - Protects your infrastructure from abuse and exploits 2️⃣ Admin Layer - Tracks API versions, logs requests, and analyzes usage - Gives engineering and ops teams full visibility into performance 3️⃣ Access Layer - Manages who can call what, and how - Supports API keys, OAuth2, JWT, and fine-grained access policies 4️⃣ Transformation Layer - Converts protocols, transforms payloads, and adapts legacy formats - Makes APIs interoperable - even when systems don’t speak the same language ⚡ Why It Matters - Boosts performance with intelligent routing & caching - Centralizes security across all APIs - Simplifies internal service calls - Enables consistent governance and scaling 🏷️ Types of API Gateways - Edge Gateways: Secure public-facing endpoints - Internal Gateways: Optimize service-to-service communication - Micro-Gateways: Lightweight, localized, service-specific 🛠️ Top API Gateway Tools - Amazon API Gateway - Kong - Apigee Edge - Azure API Management - Tyk follow Sandeep Bonagiri for more insights

140

14 Komentar

80% of the System Design interviews I’ve given in the last 7 year…have revolved around just 20% of the most practical problems I see all the time. If you’re preparing for interviews or just trying to learn System Design the right way, this is the MUST-SOLVE LIST you should explore. 1) Platform/Product Design ➠Design LeetCode   * How to handle submissions, leaderboards, and contest management at scale   * How to structure users, problems, contests, and results efficiently   * How to support real-time updates for live contests 2) Transactional Booking System ➠ Design a Ticket Booking System   * How to book individual seats vs. general admission   * How to prevent double booking and maintain strong consistency under high load   * Handling payments, cancellations, and refunds 3) Analytics/Data Pipeline ➠ Design an Ad Click Aggregator   * How to collect and aggregate massive volumes of ad clicks in real time   * Ensuring deduplication and accurate counting   * Supporting analytics queries and high write throughput 4) Messaging/Collaboration System ➠  Design Slack   * Managing channels, threads, and message storage   * How to scale for millions of users and deliver real-time updates   * User management, notifications, and permissions 5) Payment Processing System ➠ Design a Payment System   * Handling real-time and batch transactions (10,000+ per second)   * Idempotency and safe retries for external payment service integration   * Security, batching, and reconciliation logic 6) Event-Driven/Notification System ➠ Design a Webhook Callback System   * Enabling real-time event delivery to registered endpoints   * Handling failures, retries, and subscriber scaling   * Guaranteeing at-least-once or exactly-once delivery 7) Access Control/Security ➠Design a Global IP Address Blocking System   * Efficiently block requests from globally updated IP lists   * Low-latency lookups and dynamic updates   * Handling frequent policy changes and compliance 8) Distributed Caching System ➠ Design a Distributed Cache   * High availability and low-latency for frequent reads/writes   * Cache invalidation, replication, and sharding   * Consistency and eviction strategies 9) Real-Time Analytics ➠ Design a Trending Hashtags System   * Calculating top K hashtags in various time intervals (last 5, 15, 30, 60 minutes)   * Supporting local/global trends and topic filters   * Sliding window aggregation and memory efficiency 10) URL Shortening Service ➠ Design a URL Shortener   * Generating unique, collision-resistant short links   * High QPS read/write and analytics support   * Handling link expiration, custom aliases, and abuse prevention 11) IoT/Logistics Platform ➠ Design Amazon Lockers   * End-to-end from online purchase to package delivery at a locker   * Secure user access, real-time status updates, and delivery flows   * Integration with POS, logistics, and hardware Continued in Comments ↓

179

22 Komentar

What Does API Gateway Do ? Imagine a single point that not only manages traffic to your backend services but also ensures reliability, security, and speed. That's the power of an API gateway! 🔗 𝐒𝐭𝐞𝐩 1:Client sends an HTTP request to the API gateway. 🔗 𝐒𝐭𝐞𝐩 2: API gateway parses and validates the request. This involves checking for required attributes and ensuring the request format is correct, preventing malformed or invalid requests from reaching backend services. 🔗 𝐒𝐭𝐞𝐩 3: Performs allow-list/deny-list checks. 🔗 𝐒𝐭𝐞𝐩 4: The API gateway communicates with an identity provider to authenticate the client and authorize access. 🔗 𝐒𝐭𝐞𝐩 5: Applies rate limiting; rejects requests over the limit. Requests are monitored and restricted if they exceed the predefined threshold, protecting backend services from being overwhelmed by too many requests (DDoS attacks). 🔗 𝐒𝐭𝐞𝐩 6&7: Routes the request to the appropriate backend service using path matching. This involves examining the request path or URL and directing it to the relevant microservice, ensuring the request reaches the correct endpoint. 🔗 𝐒𝐭𝐞𝐩 8: The API gateway transforms the request into the suitable protocol (if needed) and forwards it to the backend microservice. It acts as a translator between different protocols (e.g., HTTP to gRPC), ensuring smooth communication between the client and backend services. 🔗 𝐒𝐭𝐞𝐩 9-12: The API gateway handles errors, uses circuit breaking for fault tolerance, leverages the ELK stack for logging and monitoring, and may cache data to improve performance. I help technical professionals build impactful career brands on LinkedIn. : Check in Comment below 👇 Create LinkedIn Diagrams for FREE using AI! Join waitlist : Check in Comment below 👇 Follow Ashish Sahu for more tech content

247

19 Komentar

The Only System Design Cheatsheet You Will Ever Need Here’s the framework given by Evan (ex-Meta) from HelloInterview that I personally love and use myself. It’s reusable, easy to understand, and works in real interviews: → Clarify the Problem (5-10 minutes) • What exactly are you building? Who's using it? • Define functional requirements: “Users should be able to…” • Define non-functional requirements: “The system should…” → Talk numbers early • Daily / Monthly Active Users • Read/write ratio (read-heavy, write-heavy, or both?) • Peak QPS and data size estimates Note: Check with interviewer if priorities should be adjusted → Define Core Entities & High-Level Components (10 minutes) • Identify key entities/objects (User, Event, Ticket, Booking) • Think about what each API will need → Sketch your system architecture • Load balancers, API gateways, microservices • Databases, caches, message queues • External services (payments, CDNs, etc.) → Design APIs for Functional Requirements (10 minutes) • Cover your top 3 functional requirements by defining the APIs: Example: REST endpoints with clear names and simple request/response payloads GET /events/search?params → Search results POST /bookings → Create booking → Deep Dive into Non-Functional Requirements (15-20 minutes) This is where you show depth. Pick 1–2 areas: • High availability & scale – Horizontal scaling, caching (Redis, CDN), DB sharding, load balancing • Consistency – Transactions, distributed locks, race conditions, isolation levels • Low latency – Search/index optimization, real-time (WebSockets/SSE), geo-distribution → Handle Bottlenecks & Edge Cases (10 minutes) • Common bottlenecks: a. DB bottlenecks → Read replicas b. High contention → Distributed locks, optimistic concurrency c. Popular events → Waiting rooms, rate limiting • Cache invalidation • Failure handling, retries • Think about production: a. Circuit breakers b. Graceful degradation c. Monitoring and alerts → Wrap Up & Future Improvements (5 minutes) Things That Actually Helped Me ✓ Leading the conversation – don’t wait for prompts ✓ Think in diagrams – use tools like Excalidraw (http://excalidraw.com/) ✓ Prioritize – focus on top 3 functional requirements ✓ Show trade-offs – every decision has pros/cons ✓ Stay organized – follow the framework and ask clarifying questions ✗ Don’t over-engineer – start simple, add complexity if needed ✗ Don’t get stuck on details – focus on data flow, not field names ✗ Don’t ignore scale – always discuss non-functional requirements HelloInterview’s Channel - https://lnkd.in/gNDkJiiu

56

6 Komentar

When it comes to writing clean, maintainable, and scalable code, the SOLID principles remain the classic standards that every developer should learn. 🔹 S (Single Responsibility): One class, one reason to change. 🔹 O (Open/Closed): Ability to add behavior without changing existing code. 🔹 L (Liskov Substitution): Subclasses should be usable anywhere their parent class is. 🔹 I (Interface Segregation): Clients shouldn't be forced to implement methods that they don't need. 🔹 D (Dependency Inversion): Rely on abstractions; don't rely on concrete classes. Altogether, these principles will make your codebase easier to read, test and change. These are all important qualities of real-world systems. Whether your app is a small-scale, or a large-scale, or a distirubuted app, applying SOLID will be the difference between brittle code and a resilient design. 👉 If you find value in content like this, follow me Nikhil Garg for more practical knowledge. 📰 Also, subscribe to my newsletter: https://lnkd.in/grqVsyCS where I break down system design concepts in a simple and implementable way!

54

23 Komentar