How this is builtGroundworkHow this is built
5 / 26 written chapters

B5 · Part 1 · Foundations

What is written and what is not

Seven of thirty-two topics are written. The other twenty-five say so rather than pretending.

6 min read1 diagram5 sections
05On this page
  1. The honest count
  2. What "planned" actually means here
  3. Where the tools reach past the writing
  4. The gaps that matter most
  5. How the counts stay honest

The honest count

The engineering on this site is ahead of the writing, and the site does not hide that. A topic with no written chapters still renders, still shows its full syllabus, and is labelled as planned rather than being quietly absent. The numbers below are computed from the content through lib/topicStats.ts, the same function the home page uses.

TopicWrittenOutlinedExercises
React570162
JavaScript41099
DSA348277
Interview book27 rounds—420 questions, no exercises
How this is built2600
System Design2400
Git16 sections—A standalone guide, not a chaptered topic
Node.js0410
Next.js, TypeScript029 each0
Nest.js0260
CSS, SQL & Databases025 each0
Testing, Web Security, Cloud & DevOps, Kubernetes024 each0
HTML, Docker, GraphQL022 each0
Redis0210
Python, Java, C++, Rust, Ruby, Go, MongoDB, DBMS, Networks, Operating Systems, Claude & AI tools0None planned yet0

253 chapters written, 358 outlined. By chapter that is 38% of the plan; by topic it is 7 of 32.

CHAPTERS, TO SCALE 227 written 366 outlined EXERCISES WITH TESTS, BY TOPIC DSA 277 React 162 JavaScript 99 Every other topic has 0. The chapter bar counts the Git guide's 16 sections as written.
The two bars do not line up, and that is the point: the exercises are concentrated in three topics, while the written chapters are spread across seven.

What "planned" actually means here

An outlined topic is not an empty page. The syllabus is written: every section has a title and the bullet points it will cover, so the outline is a genuine table of contents rather than a placeholder. Its cover renders the full map, and every outlined chapter has its own page: a roadmap card with that section's bullets, a "Meanwhile" link to a related written topic and its interview round, and prev/next scoped to the topic's own outline chapters.

What an outline does not get is attention from outside. Every outlined page is marked noindex and left out of the sitemap, so search engines are not offered 366 pages with no body; the commit that did this was titled "Stop offering 358 unwritten chapters to crawlers and readers". The cross-topic search leaves outlines out. In the site menu, a topic with nothing written sits under "Coming soon" in a muted style, and its link goes straight to the topic's own cover at /<id>, which renders a roadmap by level rather than pretending there is a reading path. The old /soon?topic=<id> and /level/<id> links still work — a redirect in next.config.ts sends each one to the same page, and the /soon page itself is gone — but nothing on the site points at them any more.

The label is computed, not typed. app/layout.tsx passes each topic's written count, from topicStats(), to every page through TopicsNavProvider, and the site menu sorts topics on it. Mark one chapter of Node.js as ready and Node moves from "Coming soon" to "Ready to read" on the next build, with nobody touching the menu.

Where the tools reach past the writing

The features built since the chapters were counted do not wait for the writing. The playground runs 11 languages whatever topic you came from. The whiteboard has nothing to do with any topic. And the mock interview gives two unexercised tracks a way to be practised:

  • The Interview book has no exercises, but its rounds are the source of the mock interview's talking stages. A question from the book arrives with a timer, a follow-up, and a rubric built from the book's own "what they are testing", "what to say" and "the trap" fields, which you mark yourself against the model answer.
  • System Design has no exercises either, but the mock interview's design round has 18 questions and a small whiteboard to draw the answer on, kept with the session so the scorecard can show it again.

The gaps that matter most

  • System Design and the Interview book still have no graded practice. Self-marking against a model answer is useful, but it is not a test that passes or fails. A design exercise that could be graded would need a format that does not exist yet: a prompt, a rubric, and something checkable about the answer. That is a content decision before it is a code one.
  • Node, TypeScript and Next.js are unwritten. React and JavaScript are now written in full, which leaves these as the three that appear in most of the job descriptions this site is aimed at, and the obvious next three to write. Node.js alone has 41 outlined chapters.
  • Exercises exist for three topics only. Every one of the 538 belongs to JavaScript, React or DSA. The grading machinery would accept an exercise from any topic whose answer is a JavaScript function or a React component; the missing part is writing them.

How the counts stay honest

Every count on this page, and on the home page, comes from one of two functions in lib/topicStats.ts. topicStats() gives each topic its written, planned, exercise and minute totals; for Git, which has no chapters, it counts the guide's sections instead. siteStats() adds those up. The topic total is one place where they disagree with the data on purpose: siteStats().topics is 30, not 32, because onShelf() in lib/topicShelf.ts leaves out the Interview book and this topic, which are reached from the site menu's links rather than the topic shelf. The home page does not print that number; it lists the shelf topics by category.

The prose is checked too. tests/claims.test.ts recomputes the written and outlined totals, the exercise count and the interview totals, and fails if the sentence under the table above, or the matching lines in four other chapters of this topic and in the README, no longer say the same thing. Writing a chapter therefore updates the site's numbers automatically, and then fails a test until the chapters that quote those numbers are updated by hand.

There is no engineering blocker on any of it

Writing a chapter means adding one file under content/<topic>/, listing it in the topic's barrel, and pointing its syllabus section at it. The page already exists as an outline, so it keeps its URL; the sitemap row, the search entry, the reading-time estimate, the progress tracking and the menu label all follow from ready: true. The thing standing between the outlines and the site is writing, not code.