Aman Sharma

Address matching is a super interesting problem and something I highly recommend trying to solve from scratch. The core idea is to determine whether two addresses refer to the same location, for example  - 221B Baker St., London NW1 6XE, UK  - 221-B Baker Street, NW1 6XE London, United Kingdom The core problem statement is to identify if two slightly different-looking address strings actually refer to the same physical location. Things become interesting as you would need to accommodate typos, abbreviations, formatting differences, missing components, or even language variations. If you give this a shot, you will learn about  - fuzzy string matching  - normalizing and parsing text data  - rule-based vs machine learning-based entity resolution  - improve match accuracy with geospatial data Again, use the LLM of your choice, but make sure you dig deeper and understand all the nuances. Hope it helps. Have fun.

1,120

34 Comments

My research paper just got published 🎉, and we were able to improve the cache-hit ratio for nginx workloads by 146%. Last week, Aayush and I were brainstorming an idea to improve the cache hit ratio, and that's when we applied Deep Q-Networks to see if we could get some major benefits. The core idea is - instead of evicting the least recently used key, we trained a small model that, given various features of an NGINX request, chooses the best key to evict among the coldest k. Give it a read to understand our thesis and nuances. The link is in the comment. The paper is titled "Cold-RL: Learning Cache Eviction with Offline Reinforcement Learning for NGINX".

4,967

75 Comments

You might be able to land SDE-II at Amazon by cheating your way through with a proxy... You might be able to become a software engineer at Google by hacking the online assessments... But what will you do when the actual work starts? • When your team hands you a feature nobody’s built before,  will you Google for answers or actually build something from scratch? • When production goes down, will you step up, or freeze because ChatGPT can’t debug your stack for you? • When you sit in code reviews and someone asks, “Why did you pick this approach?”,  will you have an answer or just blank out? • When your manager trusts you with an architectural change, can you design, justify, and own the decision, or will you hide behind jargon and hope nobody notices? I keep seeing discussions on Blind, Reddit, everywhere,  “how to game the next round,” “is anyone doing proxies for X company,” “are on-sites back?” You might have tricked an interview. But you can’t trick the work. Because the work always exposes the shortcuts. Your team isn’t dumb. Your codebase isn’t forgiving. Production bugs don’t care about your “hustle” or your hacks. And you know what stings most? If you cheat now, you’re not outsmarting the system. You’re cheating yourself out of growth. No matter how much you fake, sooner or later, the cracks show. Skill is the only thing that lasts. It’s the only shortcut that pays off, every single time. Go all in on getting better. That’s the only way you’ll be able to look back in a few years and be proud of the engineer you’ve become. You can fake an interview. You can’t fake the work. And you sure as hell can’t fake growth.

1,324

31 Comments

Why is Redis so fast? There are many design decisions that make Redis blisteringly quick. We’ll focus on two that carry most of the weight. - First is Redis’s in-memory design + single-threaded event loop. Keeping data in RAM and processing commands in one core loop avoids locks and random I/O. - Second is its purpose-built data structures and lean wire protocol. Most commands hit O(1) or O(log N) paths with tiny per-op overhead. What happens when you read from Redis👇 Step 1: A client sends a command using RESP (a simple, compact text/binary protocol). Minimal parsing and small payloads reduce CPU and network overhead. No big JSON/XML blobs. Step 2: Redis’s event loop accepts the socket and queues work. Single-threaded command execution means no lock contention or context-switch thrash. If you want to use more CPUs you need to run more Redis instances in a cluster. Step 3: The command is parsed and routed via a hash table lookup to the target keyspace entry.  Lookups are O(1) on average thanks to efficient dictionaries and cache-friendly memory layouts. Step 4: The operation runs entirely in memory using specialized structures:   Strings, lists (quicklist), hashes (compact encodings), sets/intsets, sorted sets (skiplist + hash), streams, etc. They're are engineered for predictable, fast operations with tight CPU caches. Step 5: The response is written back through the same event loop.   Pipelining and batching can amortize syscalls and round trips, pushing throughput even higher. Step 6: Persistence and replication are off the critical path.   AOF uses append-only, sequential writes with configurable fsync; RDB snapshots happen in a child process.  Basically: we can lose data! This is a tradeoff Redis makes. Replication is async by default. The slow stuff is handled in the background so the hot path stays hot. Because Redis keeps data in RAM, executes commands in a single, lock-free event loop, and uses highly optimized data structures and a lean protocol, it avoids the latency traps of disk I/O, heavy parsing, and lock contention. That’s why it’s fast. Reed more about Redis here! https://lnkd.in/g2TEVzvx

163

Netflix reduced connection churn in its API gateway by 10x. Connection churn is a massive problem with proxies like API gateways, and it effectively means the consistent opening and closing of TCP connections. Under heavy traffic, this leads to increased CPU utilization and latency. To reduce connection churn, Netflix used two things 1. H2 multiplexing - allowing multiple requests over a single TCP connection. 2. Subsetting - spread traffic across shards, each with its own connection pool. This not only reduced the number of TCP connections needed to open and close but also improved scalability i.e., with fewer connections to manage, Zuul (their API Gateway) was able to handle more traffic without sacrificing performance. They have written an amazing blog going deeper into the actual optimization and algorithm. Definitely one of the most fascinating articles I've read recently - link in the comments.

965

12 Comments

One thing your manager will never tell you Your promotion depends less on your performance and more on whether your team is actually growing. When I joined Amazon as an SDE-1, my team had 25 people. By the time I became Senior, it had 120+. Looking back, my “fast promotion” wasn’t magic. The org was expanding like crazy and growth creates opportunity. Here is the part people don’t like hearing: ❌ If your team hasn’t grown in years, your career won’t either. ❌ It doesn’t matter how good you are. There is nowhere to go. ❌ The only real path up becomes waiting for someone above you to leave. So if you want to grow faster: Choose teams that are growing. Not teams that are comfortable. Skills matter. Environment matters more.

1,037

20 Comments

You are in a system design interview at Amazon for an SDE-3 role and the interviewer has given you the question to Design Netflix. He then asks a follow up to you: How does Netflix knows when to show: Are you still watching? Is it just time-based? If it were time-based, you would see it every time. So what is actually going on under the hood? Both look like a simple pop-up. Underneath, it is a mix of product thinking, client logic, and backend events. Btw, if you’re preparing for system design/coding interviews, check out our mock interview tool. You can use it for free here: https://lnkd.in/gpCn7t2T [1] Start from the product goals The feature is not only about nagging people. - Save bandwidth and CDN cost if the viewer has slept or walked away - Avoid autoplaying potentially sensitive content in an empty room - Protect kids if parents start a show and leave the TV on - Do all this without annoying active binge watchers So the design must answer one question: "When is the user probably not here any more" [2] Naive design - pure timer Simplest idea: - If playback has been running for 2 hours, show Are you still watching - If user clicks "Yes", reset the timer Why this is weak: - Someone can binge 5 episodes in a row and gets interrupted in the middle of an intense scene - Someone can start a show, walk away after 5 minutes, and the platform will keep streaming for the next 2 hours - It ignores how many episodes were auto played, device type, time of day, user habits  [3] Realistic design - session and engagement signals Think in terms of a "watch session" and "engagement events". Signals the client can track: - Play, pause, seek, volume change - Episode finished and next episode auto started - Remote or keyboard input, UI navigation - Screen on or off events from the device - For mobiles: app background or locked state A common heuristic could be: - Count how many episodes have auto played without any user interaction - Track how long it has been since the last button press or navigation - Only trigger the prompt when both are high enough Example rule: - If 3 episodes in a row have auto played - And there has been no interaction for 45 minutes - Then, before starting episode 4, show Are you still watching This feels much smarter: - Active viewers who pause, skip intro, change volume keep resetting the "engagement clock" - Sleeping viewers do not touch anything, so the next episode is blocked by the prompt  [4] Client heavy vs server heavy design You can talk about two design choices. Client first: - All logic runs inside the app on TV, mobile, or web - Client keeps an in memory session model and decides when to show the popup - It still sends telemetry events to backend for analytics and future tuning Pros: - Works even with flaky network - Highly responsive, no extra server round trip Cons: - Logic must be implemented and updated across many platforms - Harder to quickly roll out rule changes Continued ↓

184

12 Comments

→ 𝐓𝐡𝐞 𝐌𝐲𝐬𝐭𝐞𝐫𝐲 𝐨𝐟 𝐃𝐚𝐭𝐚 𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞𝐬: 𝐖𝐡𝐲 𝐃𝐨 𝐓𝐡𝐞𝐲 𝐌𝐚𝐭𝐭𝐞𝐫 𝐌𝐨𝐫𝐞 𝐓𝐡𝐚𝐧 𝐘𝐨𝐮 𝐓𝐡𝐢𝐧𝐤? Most developers know the names. Few truly understand why each data structure exists - and how choosing the wrong one silently destroys performance. 𝐇𝐞𝐫𝐞’𝐬 𝐭𝐡𝐞 𝐬𝐢𝐦𝐩𝐥𝐞𝐬𝐭 𝐛𝐫𝐞𝐚𝐤𝐝𝐨𝐰𝐧 𝐲𝐨𝐮’𝐥𝐥 𝐞𝐯𝐞𝐫 𝐧𝐞𝐞𝐝 👇 🔹 𝐋𝐢𝐧𝐤𝐞𝐝 𝐋𝐢𝐬𝐭 • Great when insertions/deletions happen often • No contiguous memory required • Slow random access (O(n)) 🔹 𝐓𝐫𝐞𝐞 • Perfect for hierarchical data • Balanced trees give O(log n) operations • Powering DB indexes like B-Trees 🔹 2𝐃 𝐀𝐫𝐫𝐚𝐲 • O(1) index access via simple math • Ideal for DP and matrix operations • Fixed size → expensive to resize 🔹 𝐆𝐫𝐚𝐩𝐡 • Models networks, routes, relationships • BFS/DFS = fundamental pathfinding • Can be directed, weighted, cyclic 🔹 𝐌𝐚𝐱 𝐇𝐞𝐚𝐩 • Constant-time max retrieval • Critical for priority queues • Backbone of HeapSort 🔹 𝐒𝐭𝐚𝐜𝐤 • Core of recursion & function calls • LIFO = clean, structured flow • O(1) push/pop 🔹 𝐓𝐫𝐢𝐞 • Lightning-fast prefix search • Powers autocomplete and search engines • Memory heavy but extremely efficient 🔹 𝐀𝐫𝐫𝐚𝐲 • Fast indexed access • Poor for mid-insertions • Great for caching & sequential data 🔹 𝐐𝐮𝐞𝐮𝐞 • FIFO = fairness & order • Perfect for schedulers and buffering • Used in messaging systems everywhere 🔹 𝐇𝐚𝐬𝐡𝐌𝐚𝐩 • O(1) average lookup • Uses hashing + collision handling • Performance depends on load factor 🔹 𝐇𝐚𝐬𝐡𝐒𝐞𝐭 • Stores unique values only • Ideal for membership checks • Built on hash tables internally Data structures aren’t theory. They’re the difference between an app that runs… and an app that scales. follow Suresh G. for more insights

88

8 Comments

Someone mentioned on X "In compute-heavy tasks, avoid using hash data structures unless you have no choice. They are bad for cache performance, especially in NUMA setups." It looked like a very insightful statement - here are some of my random thoughts on it .. Why hash data structures can be bad for compute heavy tasks - 1. Poor Cache Locality - Hash tables involve random memory access due to their hash based indexing, which leads to cache misses and since they often involve intensive processing on large datasets, cache efficiency is crucial. In contrast, data structures like arrays, sorted vectors, or B-trees offer better spatial locality, making them more cache-friendly. 2. In NUMA systems, each processor has faster access to its local memory node. Hash tables often lead to unpredictable memory accesses across NUMA boundaries, causing expensive remote memory fetches. Sequential data structures like arrays or trees allow better memory affinity and can be optimized to stay within the local memory of a CPU core. 3. Branch Misprediction & Indirect Access - Hash tables involve pointer chasing and non-sequential memory lookups, which cause branch mispredictions and degrade instruction level parallelism (ILP). Tight compute kernels (e.g., in image processing or matrix math) rely on predictable loops and minimal indirection to fully utilize SIMD pipelines and modern CPU execution units. However when a problem involves frequent key-based accesses rather than sequential scans, hash tables remain the best option. And there are some alternatives like Flat Hash Maps (e.g., Google's absl::flat_hash_map, Rust's hashbrown using Robin Hood hashing) that can reduce pointer indirection and improve cache locality. In summary: - If your workload is truly compute-bound (e.g., SIMD-based, matrix multiplications, large-scale simulations), avoid hash tables when possible. - If your workload is lookup-heavy, hash tables remain useful but should be optimized for cache locality (e.g., Robin Hood hashing, flat maps).

42

3 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

Stripe migrated 1,500,000,000,000,000 bytes of data (bin-packed 1000s of under utilised databases) Reducing the total number of underlying DocDB shards by ~3 quarters # Problem Ability to migrate data across database shards in a client-transparent manner with following requirements 1. Zero downtime 2. Ensure data being migrated remains consistent and complete across both source and target shards 3. Support migration of an arbitrary number of chunks of data from any number of sources to target shards # Solution Stripe built Data Movement Platform to manage online data migrations across database shards # Architecture 1. First, intent is registered in chunk metadata service to migrate database chunks from source shards to arbitrary target shards 2. Snapshot of chunks on source shards at a specific time (T) is used to load the data onto one or more database shards. 3. Sorting the data (on common index attributes) in collections and inserting it in sorted order boosted write throughput by 10x. 4. To replicate writes starting at time T, async replication read the mutations from writes on the source shards (from the CDC systems) and issue writes to the target shards 5. After replication syncs source and target shard, comprehensive check is conducted for data completeness and correctness by comparing point-in-time snapshots 6. Once data is imported from source to target shard and mutations are actively replicated -----> Traffic switch is orchestrated by the Coordinator. 7. Traffic switch protocol takes less than 2 secs to execute 8. Migration is concluded by marking the migration as complete in chunk metadata service and subsequently dropping the chunk data from the source shard over to you, how to handle failed reads and writes during traffic switch? # Reference and Image Credit - stripe .com/blog/how-stripes-document-databases-supported-99.999-uptime-with-zero-downtime-data-migrations #SystemDesign #architecture --- Understanding the First Principles is the key to Effective Learning! 🔔 Follow Kamran to Improve System Design Skills through case studies

115

41 Comments

Kafka doesn’t mean zero-loss. Even with acks=all! A lot of folks assume writes with “acks=all" is safe enough. A few things to keep in mind: 1. Broker can ack before it is fsync'ed to disk from OS Cache. So, if a node dies before fsync'ing, the message can be lost. 2. A follower is behind the leader but it may still be considered as in-sync due to a lag configuration too liberal for your case 3. Producer batching opens up loss windows 4. Disks and firmware sometimes lie about durability(not Kafka specific). Tuning configs(like acks=all, min.insync.replicas=2+, disable unclean leader election) helps, but can't fully solve this. This eventuality should not be a surprise since Kafka prioritises performance by design, and it does not use safer options like consensus algorithms in its write path deliberately. If your high throughput system requires delivery guarantees or at least can't stay unaware of a silent loss, one must uncover edge cases conceptually or in practice. Use guardrails like auditing, checksums, reconciliation and chaos drills end-to-end. PS - An interesting alternative I came across is RedPanda which claims to solve this by using fsync and raft consensus on every write. I haven't dived deep into it, but at this point, it is counter-intuitive to me as consensus is too costly to run in data plane i.e., on every message write(unless they have some clever ways I am unaware of).

93

35 Comments