This edition of the newsletter contains
Btw, enrollments are open for my Systems Design October cohort (sessions start 11th Oct). If you'd like to dig deeper into systems, their implementation, and how to design them the way they actually run in production, check out:
The course is completely no-fluff and packed with brainstorming and discussions that will shape your thought process and intuition. You'll feel like you're part of a real technical discussion happening at your workplace.
Frequent job switches can be great for short-term financial gains. I believed that early in my career as well, but here's what I've learnt over the years.
I switched roles frequently, chasing better compensation and new challenges. And honestly, it worked - but only for a while. Over time, I realized something: quick jumps don't always compound well.
If your profile shows a pattern of constant movement and switches, it can become a red flag - especially for roles that demand deep ownership or long-term bets, like leads and staff positions.
These days, I am optimizing for career longevity. When you are at your peak earning potential, just a couple of extra years at that level can easily surpass the small hikes you would gain from frequent moves. For example, 2x of a larger number is much bigger than 5x of a much smaller number.
Staying relevant in the industry, growing within a role, and building leverage are things that can open bigger opportunities and, more importantly, create long-term wealth - not just better paychecks.
That said, this certainly doesn't mean settling for something less. If a role stagnates, a company stops evolving, or you're no longer learning, it's time to move on. The key is to ask: “Am I still growing? Am I building something meaningful?”
Think in decades, not quarters.
Being hands-on is the best way for you to learn. Practice interesting programming challenges like building your own BitTorrent client, Redis, DNS server, and even SQLite from scratch on CodeCrafters.
Sign up, and become a better engineer.
I published a video - How an Edge Case Caused the GitHub Downtime
In this video, I have dissected a major GitHub outage that resulted in widespread downtime. The root cause of this issue is an often-overlooked edge case, and I have dug deeper into the nuances of what happened, why it happened, and the critical lessons we can learn from this incident.
I spent some time reading Leaper: A Learned Prefetcher for Cache Invalidation in LSM-tree based Storage Engines
Some time back, I read a paper titled Leaper from Alibaba that asks this simple question: What do you do when compactions constantly invalidate your cache?
Traditional schemes that use page-based LRU/LFU don't work because compactions move the blocks around, destroying the cache locality and statistics. This can be seen with correlated latency spikes and cache miss spikes during compaction.
The paper talks about an ML-based approach that predicts future hot key ranges before compaction hits and prefetches relevant blocks into the cache. The ML Model (binary classification) is pretty lean with extremely minimal overhead.
The paper has some really good insights into cache invalidation. This is one of the first papers I read in which ML is running within the database, which opens up so many interesting explorations :) If you like databases or data structures, you will find this paper super interesting and will literally finish it in a single sitting.
You can download this and other papers I recommend from my papershelf.
I read a few engineering blogs almost every day, and here are the three articles I read and would recommend you read.
Thank you so much for reading this edition of the newsletter 🔮 If you found it interesting, you will also love my courses
I keep sharing no-fluff stuff across my socials, so if you resonate, do give me a follow on Twitter, LinkedIn, YouTube, and GitHub.
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.