System Design 101 traded its diagrams for 500 links
GitHub keeps re-trending a repo whose famous content moved to ByteByteGo's site in 2025.
System Design 101 is back on GitHub's daily trending list, which happens to this repo every few months. It has 88,000 stars, a one-line pitch about explaining complex systems with visuals, and a name that sounds like a course. But the repo people starred in 2023 no longer exists. The content left GitHub last year, and what remains is a table of contents.
The gap between the star count and the current artifact says a lot about how trending repos work as a genre. And the underlying material still poses a question for anyone prepping system design interviews: what is diagram-based prep actually good for?
From viral README to link index
The repo launched on October 16, 2023 from ByteByteGo, the company behind Alex Xu's System Design Interview books and the diagram-heavy newsletter of the same name. Three days later it was #1 on GitHub trending. The thing that went viral was a single enormous README: inline diagrams with explanatory text covering load balancing, gRPC, caching, API design, and a few dozen other topics. The commit history shows what it was. Contributors filed PRs to fix a stackoverflow.jpg typo, reorder a gRPC diagram relative to its text, and correct the load-balancing list. The content lived in the file, and the community edited it.
On April 1, 2025, commit #106 ("Adds ByteByteGo guides and links") replaced that with the current structure: a banner image and roughly 500 links across 12 categories, every one pointing at a guide page on bytebytego.com. No inline diagrams, no inline text. I checked the guide pages; they're free to read, full content, no signup wall. Call it a migration rather than a rug pull: free content moved from a platform ByteByteGo doesn't control to one it does, where the company gets analytics, SEO juice, and a newsletter box next to every diagram.
Two details sharpen the picture. First, the license was always CC BY-NC-ND 4.0: non-commercial, no derivatives. Despite the GitHub packaging, this was never open source in any meaningful sense; you couldn't fork it and build on it legally even in 2023. Second, the stars are inherited. Roughly all of them predate the restructure, earned by a self-contained document that's no longer at that URL. When the repo trends today, GitHub is surfacing a marketing index on the strength of social proof a different artifact accumulated.
I don't think ByteByteGo did anything wrong here. But developers should read trending the way they read app store rankings: as a popularity signal with a lag, not a review of what's currently in the box.
The shallow-vs-distilled fight, still unresolved
When the repo hit Hacker News in 2023 (250 points), the thread split cleanly. One camp: the diagrams are shallow bullet-point content, and you can't assimilate distributed systems from pictures; you need to feel these systems fail in production. The other camp: distilling a complex topic to something you can absorb in five minutes is hard editorial work, and this does it better than the GeeksforGeeks tier it displaced.
Both camps are right, and the resolution is about sequencing. Diagram content is a vocabulary layer. It tells you that consistent hashing exists, what a write-ahead log is for, why you'd put a CDN in front of an origin. That's precisely the layer system design interviews test at the L4-and-below range, which is why this material converts so well: the interview format and the content format are the same shape, boxes and arrows narrated confidently for 45 minutes.
What the format can't carry is trade-off reasoning under constraints, which is what senior interviews and actual production work demand. A diagram of Kafka doesn't teach you when a partition rebalance will wreck your consumer lag, or why exactly-once semantics come with asterisks. For that layer you still want Designing Data-Intensive Applications, the MIT 6.824 labs where you implement Raft yourself, and Jepsen analyses, which are the best free corpus of "here's how the diagram lied to you" ever assembled.
How to actually use it
Treat the repo as what it now is: an index. Skimming the 500 links is a decent way to find gaps in your vocabulary a week before an interview loop. Read the guides on topics you can't explain aloud, then go one level deeper on the two or three that your target company plausibly cares about.
If you want the original self-contained version, the one the stars were for, it's still in git history. The last content commit before the restructure landed December 27, 2023:
git clone https://github.com/ByteByteGoHq/system-design-101
cd system-design-101
git checkout 44f1251199
That gets you the full inline README, greppable and readable offline. It's frozen at the end of 2023 and the ND license means you can't republish a cleaned-up fork, but for personal interview prep the frozen version is arguably the better artifact. It has no funnel attached.
My verdict: the material is fine, the packaging is the story. System Design 101 is a well-executed content funnel that keeps re-trending on borrowed social proof. A GitHub repo can go viral as a document, hollow out into an index eighteen months later, and keep collecting stars because nobody re-reads what they've already starred. Check the commit log before you trust the number.
Sources & further reading
- ByteByteGoHq/system-design-101 — github.com
- System Design 101 — news.ycombinator.com
- ByteByteGoHq/system-design-101 - GitHub trending stats — trendshift.io
- How does gRPC work? — bytebytego.com
Priya covers AI frameworks, developer productivity tooling, and the startup ecosystem across South and Southeast Asia, bringing a researcher's rigour and a practitioner's empathy to every story. She is deeply sceptical of benchmarks and asks hard questions so her readers don't have to.
Discussion 7
link dump isn't system design prep, it's a bookmark folder. if you can't explain why a load balancer goes *there* vs *there*, or what breaks under what conditions, shuffling through 500 ByteByteGo links won't fix it. tests would though—can you design the same system twice and get consistent reasoning? that's the signal.
theo nailed it. we had a incident two years back where a junior kept pulling diagrams off these curated lists during postmortems instead of actually reasoning through the failure mode. turned out they'd never *built* anything that broke. once we threw them at a live service with actual constraints and rollback windows, suddenly the diagrams meant something because they had to defend design decisions under pressure. links are reference material, not understanding.
that's the real litmus test though—do the diagrams help you think through trade-offs or just give you vocabulary to sound confident? i'm curious whether you found it helped more once they had to actually operate what they built, or if hands-on experience with failure is just fundamentally different from studying someone else's postmortem.
honestly, this lands for me because i spent last year debugging a distributed cache layer that looked textbook-perfect on whiteboard but choked under real contention. the diagrams got us hired, but the postmortem taught us why our locking strategy was fundamentally wrong. i think diagrams are maybe 20% of the battle—they teach you *names* for problems, which matters, but they don't teach you how a system *feels* when it breaks. that part only comes from operating something that actually fails under load.
totally agree on the reasoning part, but the brutal part is that systems don't really have repeatable "correct" answers the way code does—you can design the same thing three ways and all work fine depending on scale, latency budgets, team expertise. so a test framework gets messy fast. links are lazy, sure, but they at least let you pattern-match against real tradeoffs instead of memorizing one person's favorite architecture.
yeah, but doesn't that argue *against* a link dump? if the problem is that every design has multiple valid answers depending on context, then what you actually need is the reasoning layer—like, here's the tradeoff space and here's how to navigate it. links just punt you back to reading docs. what would actually stick is working through a few real systems where you had to justify your choices against specific constraints. have you found a resource that actually does that, or is it all just case studies at this point?
totally agree on the consistency signal, though i'd add: the licensing and sustainability angle here is gnarly. someone built a teaching resource, it got popular enough to be valuable, and now it's basically a redirect to a paid/freemium platform. that's not inherently wrong, but it does mean anyone forking this for their own course or study group doesn't actually have the artifact anymore—just links that could vanish or change. that's different from a traditional OSS educational project, where the community at least owns the material.
