The notes in this vault are a map. Projects are the territory — what turns “I read about it” into “I built it and can prove it.” Reading is not reps; building is.

This file is now the index. Every course domain has its own projects.md sitting next to its notes, so the reps are findable from the course rather than from here.

How to use this

  • Pick one and finish it. One shipped project beats five half-started ones. Finishing — deployed, tested, written up — is the skill.
  • Extend your real projects where you can. Adding CI/CD or benchmarks to something you already built is higher-signal than a toy, and faster to start → projects/.
  • Write it up. A short README with the why and what you learned turns a project into portfolio signal.
  • Every entry has a done when. If you can’t say when a project is finished, you’ll either stop early or never stop.

Difficulty: 🟢 starter (hours–days) · 🟡 intermediate (a week or two) · 🔴 ambitious / portfolio-grade. ⭐ = highest signal.


The per-domain ladders

DomainThe one to do first
BackendLoad-test and fix your own p99
FrontendThe same app three ways — local state, server state, RSC
DatabasesA zero-downtime migration on a live table
Data EngineeringThe end-to-end mini-pipeline, then break its idempotency
Data AnalysisA real diagnostic (“why did this change?”), then the full analyst one-pager
ArchitectureA Raft key-value store
DevOpsContainerize and deploy one app end to end
CybersecurityPortSwigger’s Academy, then secure your own app
Web3Token and wallet from scratch, then break your own contract
AI & MLRAG over this vault
FoundationsThe regex engine — one evening, theory becomes code
LanguagesThe same program in three languages
MobileSurvive process death, then ship a small app to a store
GitThe disaster drill — an hour, and git stops being scary
HardwareRev 2 of the IoT Bridge
RoboticsSomething moving in ROS 2 + Gazebo
Game DevShip a game jam entry
Control theoryBalance a physical inverted pendulum
Operations researchModel a decision you actually make, and live with the answer for a week

If you only do five

Highest signal for where you’re aiming, across all four columns of the path:

  1. 🔴 ⭐ The order-book matching engine (Java / systems) — below
  2. 🔴 ⭐ RAG over this vault (AI engineering) → ai-ml projects
  3. 🔴 ⭐ An end-to-end MLOps project (ML engineering) → ai-ml projects
  4. 🟢 ⭐ Containerize + deploy one app (DevOps) → devops projects
  5. 🟡 ⭐ Secure your own app, then attack your own lab (security) → cybersecurity projects

Hardware is the exception — the one column where you already have more built than written, so it needs the fewest new projects and gives the fastest returns → hardware projects.


Java / JVM & Systems

The low-latency / systems signal — what a firm doing market-data / FPGA work actually screens for. This is where you have the most to prove and the most upside. Kept here rather than in projects because it’s a career target, not a language tour.

  • 🟢 Solve the concurrency exercises — the bounded blocking queue and token-bucket rate limiter already have a red→green test harness. Do both — once with synchronized, once lock-free with ReentrantLock/atomics. Exercises: concurrency.
  • 🟡 Lock-free ring buffer (SPSC/MPSC queue) — a bounded ring buffer using AtomicLong cursors and CAS, no locks. Benchmark it against ArrayBlockingQueue. The canonical low-latency data structure (the LMAX Disruptor’s core). Exercises: atomics/CAS, memory model.
  • 🔴 ⭐ In-memory order book + matching engine — a limit-order book (price levels, bid/ask, add/cancel/match) with a matching engine, single-threaded on the hot path for determinism. Feed it a synthetic order stream, measure throughput and p99 latency. This is the single most on-target project for a trading firm — it’s literally the domain.
  • 🟡 Market-data feed parser — parse a binary/CSV market-data feed (or a simplified FIX/ITCH-style format) at high throughput, zero-allocation on the hot path. Ties batch/streaming to the language.
  • 🟡 JMH benchmark + GC tuning study on your record-generator pipeline — add JMH microbenchmarks, then run it under different collectors (Parallel vs G1 vs ZGC), capture GC logs / a JFR recording, and write up the latency-vs-throughput tradeoff. Exercises: JVM internals — GC/JIT in practice, the exact thing the notes say only doing teaches.
  • 🟢 Add a real test suite to one of your Java projects — JUnit + Mockito + a Testcontainers integration test against real MySQL/RabbitMQ. The projects shipped without tests; fixing that is direct engineering-maturity signal. Exercises: testing.

⭐ Build-Your-Own — systems mastery

The deepest reps in the vault. Each one turns a whole topic from words into bone-deep understanding.

These now have full build guides in build-your-own-shit/ — numbered milestones, each independently testable, with per-language toolkits and a “where to stop”. Read the guide rather than this list; the entries below are the one-line pitch and the difficulty rating.

GuideWhy
🟠HTTP serverStart here. A weekend; a real browser is the test
🟠ShellThe smallest one that teaches the most — fork/exec, fds, pipes
🟠Container~200 lines, one evening, and Docker stops being magical
🔴GitReal Git reads your repository. Permanently demystifies it
🔴 ⭐RedisData structures + networking + durability. The real redis-cli connects
🔴Language / interpreterThe deepest single lesson. → compilers is the course behind it
🔴DatabaseB-tree, SQL subset, WAL. kill -9 mid-write and the data survives
🔴Operating systemWeeks, not a weekend. Boots from a USB stick → os
🔴 ⭐Raft key-value storeThe best distributed-systems project there is. Kill the leader mid-write and nothing committed is lost
🔴TCP/IP stackping answers, then the HTTP server above runs on your own TCP
🟠CompressorA weekend, and gunzip reads your output
🟠Ray tracerThe shortest path here to something you want to look at
🔴Debuggerptrace, ELF and DWARF — and gdb to check yourself against
🔴Your own LLMAttention, trained from scratch. The sequel to the neural network

Pair each with a short write-up of what you learned; these are portfolio-grade signal on their own.


Product ideas

Ideas for things other people would use, not just practice reps. The e-learning platform became active on 2026-11-14; the interactive knowledgebase is its prototype.

  • 🔴 An e-learning platform, W3Schools-style. Lessons in order with next/back, quizzes after every few lessons, and “write your own code” exercises checked by real tests. The vault already has the content (course standard, checks sections, labs with tests), so the platform is the product, not the material. What makes it a platform rather than a static site:
    • Accounts and progress that follow you across devices (auth plus a database).

    • A code runner. JS/TS in a Web Worker and Python via Pyodide both run in the browser. Go, Rust, C, Java and C# need a sandboxed server that runs untrusted code (Judge0-style), which is its own security project.

    • Grading: the learner’s code runs against the lesson’s lab tests, and the pass/fail result is stored.

    • Later, maybe: certificates, payments, authoring tools for other teachers.

    • Who it’s for (decided 2026-11-14): a junior developer (0–2 years) who can ship apps but stalls on the fundamentals underneath them, and wants to become a genuinely strong engineer and get to mid-level. Students are the second audience: a CS student becomes this person a year later. Launch for the junior, because they can pay, they already know what they’re missing, and I am one.

    • Why they’d pick it: the real competitors are boot.dev, Frontend Masters, Educative, ByteByteGo, roadmap.sh, Exercism, YouTube and AI. Draft pitch: “The CS degree you didn’t get, taught through the systems you use at work, with labs that run on real tools, in your language.”

      • University depth for practitioners is the headline. Depth alone isn’t unique; what’s unique is that every theory is tied back to a system the learner uses at work.
      • Labs verified with real tools are the proof. They’re also the most expensive feature, because real tools mostly need servers.
      • Eight languages, sold as “in your language” (learn it in the stack you use at work) rather than as a comparison of languages.
    • Languages at launch: code you can read is shown in every language from day one, since it’s already in the vault and is just static text. Code you can run and get graded is JS/TS and Python only at launch, since both run in the browser for free. Go, Java and the rest become runnable later, on a server. Label the read-only samples clearly (“Go: read-only for now”). SQL may be runnable early through PGlite.

    • Plans (decided 2026-11-14): the content is free, because the vault is already public and nobody pays to read. Free users get a taste of graded exercises, so they feel the difference before being asked to pay.

      FreePlusPro
      All lessons, every language✅✅✅
      Progress tracking✅✅✅
      Quizzes✅✅✅
      Graded exercises (JS/TS, Python)First lesson per courseAllAll
      Certificates and portfolio—✅✅
      AI tutor—Limited✅
      Human review of projects——✅
    • Testing before payments: no payment gateway yet. A plan switch in settings lets coursemates try every tier. The plan is stored on the server, and the server checks it before anything paid runs, so the gateway later only changes how the plan gets set. The switch shows the price it would cost, every click is logged, and testers are asked “would you have paid this?” Coursemates are students (the second audience), so read their price feedback with that in mind.

    • Content architecture (decided 2026-11-14):

      WhereWhat
      Public vaultLessons (each with a UUID id in frontmatter), code in every language, visible tests (the labs), quiz questions
      Private repoHidden tests, quiz answers, reference solutions, linked by lesson UUID
      Platform repoThe app code
      DatabaseUsers, plans, progress, submissions, plan-switch clicks
      • The vault stays the only place lessons are edited. The platform reads it at build time as a git submodule.
      • IDs are UUIDs, added by a script. A check fails the build on a missing ID, a duplicate ID, or a removed ID that users may have progress on (compared against the previous ID list).
      • A second check makes sure every hidden test points at a lesson ID that exists and passes against the reference solution.
      • Practice exercises run in the browser against the visible tests. Certificate exercises run on the server against the hidden tests, because anything sent to the browser can be read.
    • Stack (default decisions, 2026-11-14):

      • Next.js (App Router) + TypeScript, one app with no separate backend. It’s already the stack I know.
      • Supabase for Postgres, auth (email plus Google) and row-level security. The plan is a column on profiles, and only the server can change it.
      • Vercel for hosting. The free tiers of Vercel and Supabase are enough for the coursemate test.
      • Markdown rendering with unified/remark/rehype, the same pipeline as Quartz, plus a resolver for [[wikilinks]]. Lesson order comes from the course index files.
      • Browser runner: JS/TS in a Web Worker, with TypeScript types stripped by sucrase, and a timeout that kills runaway loops. Python through Pyodide, loaded only when someone opens a Python exercise.
      • Server runner for certificate grading: deferred until after the first milestone. When it’s needed, use a self-hosted sandbox such as Judge0 or Piston rather than building one.
      • Payments: deferred, as decided. Paystack is the first candidate, since it handles Naira.
    • Milestone 1, the coursemate test: sign up, read SWE 101 with next/back, take quizzes, run graded JS/TS and Python practice exercises in the browser, see progress, and switch plans with the price shown and clicks logged. Certificates, the AI tutor, human review and the server runner wait until after this.

    • Name: I Sabi (“I know it” in pidgin), a Spectroniq product. Written “I Sabi” in text, and isabi in URLs and repo names. Lives at isabi.spectroniqlimited.com for milestone 1. Before a public launch, consider a short domain of its own, redirecting from the subdomain.

    • Status: active since 2026-11-14, alongside NextVibe.

    • Done when: one full course (SWE 101) is live with accounts, quizzes and in-browser JS + Python exercises, and 10 people outside my circle have finished at least one week of it.

  • 🟢 Interactive knowledgebase (the small version of the above). Add it to the Quartz site, all on the front end: prev/next links from the course index order, a ```quiz block plugin (like quartz-plugins/abbreviations) with progress in localStorage, and an in-browser JS/Python runner for one lesson. Doubles as the prototype for the platform’s lesson and quiz format.
    • Done when: one SWE 101 lesson has all three, and I’ve used its quiz while actually studying it.

↑ Back to Kingsley's Knowledge Base