North Star Artifacts — The 7 Portfolio Rungs

From July 6, 2026 to July 5, 2027. Seven public artifacts. Two are hard gates. Every one of them is dated, benchmarked, and visible on the internet.

The portfolio ladder is the only durable proof that this fortress worked. Every course you finish, every book you read, every 30-minute session you log — they matter only insofar as they feed one of these seven rungs. If a chapter or file in the fortress does not eventually cascade into a public artifact, it is either scaffolding or ego. Learn to feel the difference.

The two hard-gate rungs (Rung 5 at M9, Rung 6 at M11) are the ones that make the M13 pitch sentence defensible. If you ship those two and nothing else, you can still hold your head up in an ML-infra study. Everything else is amplification.

The Ladder At A Glance

Rung 1 — c-toolchain-journal (M1, ships August 2, 2026)

What it is: A public GitHub repo containing an annotated Makefile, 5 documented gdb sessions on real segfaults, 5 documented AddressSanitizer catches, and a README explaining the compiler-flag hardening baseline you use everywhere in this fortress.

Where it lives: github.com/<yourhandle>/c-toolchain-journal Full spec: 12_portfolio/01_rung_1_toolchain_journal.md

Signal it sends: You reason about tools before you reason about code. You know the difference between -O0 -g and -O2 output. You have used gdb, not just installed it. Specificity gradient: Beginner-accessible. Any C learner can attempt this. What separates yours is documentation quality — the writeups, not the code.

Publication targets:

  • GitHub public with clear README

  • Cross-post: one r/C_Programming “just starting out” thread with the link

  • LinkedIn post: “Starting my 13-month C journey. Rung 1 shipped.”

Rung 2 — libprep (M3, ships September 27, 2026)

What it is: A single-header (or single-.c + .h) container library with 5 data structures: dynamic vector, string builder, hash map, min/max heap, deque. Full test suite, 90%+ line coverage, ASan clean, README with API examples for each container, complexity table.

Where it lives: github.com/<yourhandle>/libprep Full spec: 12_portfolio/02_rung_2_libprep_containers.md

Signal it sends: You can design a small library’s API. You know ownership boundaries. You can write real test coverage in C — which is rarer than it should be. Specificity gradient: Intermediate. This is where casual learners drop off (they write one data structure and never test it).

Publication targets:

  • GitHub public with badge for CI green + coverage

  • Cross-post: r/C_Programming with the sentence “looking for API feedback”

  • Use it in Rung 3 (dogfood test)

Rung 3 — neetcode-75-in-c (M5, ships November 22, 2026)

What it is: All 75 NeetCode problems solved in idiomatic C. One folder per problem: solution.c, test.c, README.md (with time/space complexity and a note on why C makes this problem harder than Python). 5 hardest problems get a longer writeup and cross-post.

Where it lives: github.com/<yourhandle>/neetcode-75-in-c Full spec: 12_portfolio/03_rung_3_neetcode75_in_c.md

Signal it sends: You are DSA-fluent in a language that has no HashMap in the standard library. You did not reach for Python when it got hard. Specificity gradient: Intermediate. LeetCode-in-Python is common; LeetCode-in-C is rare, and the ones that exist are usually incomplete. Full 75 is a real credential.

Publication targets:

  • GitHub public

  • 5 hardest writeups: r/C_Programming and dev.to

  • LinkedIn post at rung-ship with the summary metric (75/75, avg time per problem)

Rung 4 — nsh (M7, ships January 17, 2027)

What it is: A POSIX-compliant mini-shell written from scratch. Features: fork/exec with PATH resolution, multi-stage pipes (|), redirects (<, >, >>), background jobs (&), signal handling (SIGINT for foreground jobs, SIGCHLD reaping), history (up-arrow via readline or hand-rolled), tab completion (basic). ~2000 LOC. Passes a 30-scenario scripted test suite. Demo GIF in README.

Where it lives: github.com/<yourhandle>/nsh Full spec: 12_portfolio/04_rung_4_mini_shell.md

Signal it sends: You understand the Unix process model, not just the shell as a user. You know fork/exec, waitpid, dup2, signals, and terminal control. This is the rung where you stop being “a programmer who uses Linux” and start being “a programmer who could write Linux userland.” Specificity gradient: Advanced-intermediate. Every OS course assigns a shell; almost nobody polishes it to demo quality.

Publication targets:

  • GitHub public with demo GIF

  • Cross-post: r/C_Programming + r/unixporn (yes, seriously — they love terminal work) + Hacker News “Show HN: nsh”

  • Blog post: “What I learned writing a Unix shell from scratch”

Rung 5 — epoll-http-server — 🟧 HARD GATE #1 (M9, ships March 14, 2027)

What it is: A single-threaded, non-blocking, epoll-driven HTTP/1.1 echo server with keep-alive support. Serves static files. Benchmarked at 100,000+ requests per second on a 4-core laptop using wrk. 24-hour leak-free soak test under sustained load. ThreadSanitizer clean when combined with an optional worker-thread mode. Reproducible benchmark script. Long-form blog post published with graphs.

Where it lives: github.com/<yourhandle>/epoll-http-server + blog post + Show HN Full spec: 12_portfolio/05_rung_5_epoll_http_server.md

Signal it sends: You can build the concurrency substrate of a real service. You know why redis uses level-triggered epoll (06_concurrency_and_networking/08_a_production_server_walkthrough.md). You know why TIME_WAIT is a thing. You have seen EAGAIN, EPIPE, and ECONNRESET and made peace with them. Specificity gradient: Expert-signal. Very few people ship a public non-blocking server with a real benchmark. Fewer still soak it for 24h. This is the rung recruiters at Cloudflare, Neon, Redis, and Bengaluru infra shops will click through to first.

Publication targets:

  • GitHub public with benchmark graph in README

  • Blog post 1500+ words: methodology, choices made, tradeoffs, what was hard

  • Cross-post: r/programming, r/C_Programming, Show HN

  • LinkedIn post targeting infrastructure roles

Hard gate acceptance criteria (all must be true):

  • wrk -t8 -c1000 -d60s http://localhost:8080/ sustains ≥100k RPS on your laptop

  • After a 24h wrk soak, /proc/<pid>/status shows stable RSS (no leak drift)

  • TSan run under wrk -t8 -c1000 -d60s produces zero warnings (with worker-thread mode enabled)

  • Show HN post has ≥50 points OR the blog post has ≥500 unique views

  • All three metrics reproducible via a scripted ./benchmark.sh

Slippage rule: If Rung 5 does not ship by March 21, 2027 (one week grace), invoke 99_pre_mortem/09_summary_and_reset_protocol.md. Do not power through. Scope down (drop keep-alive, or drop TSan clean, or drop 100k target to 50k) and ship a smaller version publicly. A shipped smaller version beats an unshipped bigger one.

Rung 6 — simd-gemm-benchmark — 🟧 HARD GATE #2 (M11, ships May 9, 2027)

What it is: A public benchmark repository comparing four matrix-multiplication implementations on a chosen matrix size (e.g., 1024×1024 fp32): (1) naive triple loop, (2) cache-blocked, (3) SIMD (AVX2 on x86 or NEON on Apple Silicon), (4) OpenBLAS reference. The SIMD implementation must land within 3x of OpenBLAS on GFLOPS. Roofline plot for your machine. Long-form blog post (≥2000 words) walking through the optimizations.

Where it lives: github.com/<yourhandle>/simd-gemm-benchmark + blog post Full spec: 12_portfolio/06_rung_6_simd_gemm_benchmark.md

Signal it sends: You think like an ML-infra engineer. You know that “just use PyTorch” is not always the answer. You have seen the roofline. You have profiled with perf and understand memory-bandwidth-bound vs compute-bound. This is the rung that opens the ML-infra door. Specificity gradient: Expert-signal. Roofline-analysis blog posts on the internet are rare. Ones written by someone who was doing Applied ML at Zoho 12 months prior are rarer.

Publication targets:

  • GitHub public with benchmark reproducibility scripts

  • Blog post 2000+ words: naive → blocked → SIMD → roofline → gap to OpenBLAS

  • Cross-post: r/MachineLearning, r/programming, HN, LinkedIn ML-infra target

  • Talk pitch: apply to a Bangalore ML meetup (HasGeek, Cypher, MLOps.community BLR)

Hard gate acceptance criteria (all must be true):

  • SIMD implementation lands within 3x of OpenBLAS on GFLOPS at target size

  • Roofline plot committed to the repo (SVG or PNG, reproducible)

  • Blog post published with URL, ≥2000 words, at least one figure

  • Reproducible benchmark via ./bench.sh on a documented machine

  • Applied to at least one meetup with the blog post as the pitch

Slippage rule: If Rung 6 does not ship by May 16, 2027, invoke reset. Scope down: drop the 3x-of-OpenBLAS target (allow 5x), or shrink the matrix size, or narrow to NEON-only. Ship the smaller version publicly.

Rung 7 — Merged OSS PR + Journey Blog (M13, ships July 5, 2027)

What it is: At least one merged pull request into a top-tier C open-source project. Target list (in order of recommendation, per verified 2026 findings): (1) Valkey — github.com/valkey-io/valkey, TOP PICK, Linux Foundation backed, maintainers Madelyn Olson (AWS), Roberto Luna Rojas (AWS), Kyle Davis. (2) llama.cpp — github.com/ggml-org/llama.cpp, high PR volume, ML-adjacent signal. (3) curl — github.com/curl/curl, most beginner-friendly historically, Daniel Stenberg reviews weekly.

PR must be non-trivial: ≥200 LOC change OR documented significance (bug fix with a linked CVE, meaningful feature, meaningful performance improvement). Plus a 1500+ word blog post: “What I learned shipping to .”

Where it lives: Whichever repo the PR merges into + your blog Full spec: 12_portfolio/07_rung_7_oss_merged_pr.md

Signal it sends: You ship alongside experienced maintainers. You survived the code-review process. You can read someone else’s C and add to it. This is the rung that closes the M13 pitch clause “C that ships in production.” Specificity gradient: Expert-signal. Merged non-trivial PRs to Valkey / llama.cpp / curl are visible on the maintainers’ contributor list forever. Google-searchable. Immutable.

Publication targets:

  • The upstream repo (permanent record)

  • Blog post 1500+ words on the journey

  • LinkedIn post announcing the merge

  • Update your resume: this is now a work sample, not a hobby

Not a hard gate but: if by June 21, 2027 (start of S26) you have not opened a PR anywhere, drop scope to a smaller repo (any active C project with good-first-issue open). A merged small PR beats an unmerged big PR.

The Specificity Gradient — Reading the Ladder

Each rung is intentionally more specific and less common than the previous.

Rung

How many C learners could ship this?

What separates yours

R1

Millions could

Documentation quality

R2

Hundreds of thousands could

90%+ coverage, ASan clean

R3

Tens of thousands could

Full 75, written up

R4

Thousands could

Polish and demo GIF

R5

Hundreds could ship 100k+ RPS

24h soak + benchmark

R6

~100s could match 3x of OpenBLAS

Roofline + writeup

R7

~thousands ship OSS PRs, few write it up

The reflection + arc

At Rung 5 and Rung 6, the world narrows sharply. The pitch sentence in 07_thirteen_month_pitch.md was reverse-engineered from those two.

Rung → M13 Pitch Sentence Mapping

“I write C that ships in production — from SIMD-accelerated ML inference kernels to multi-threaded network services — and I can debug someone else’s segfault at 2 AM without flinching.”

Pitch clause

Which rung(s) earn it

“I write C that ships in production”

Rung 7 (merged PR)

“SIMD-accelerated ML inference kernels”

Rung 6 (hard gate #2)

“multi-threaded network services”

Rung 5 (hard gate #1)

“debug someone else’s segfault”

Rung 7 + Rung 1

“at 2 AM without flinching”

Rung 4 + Rung 1

Rungs 2 and 3 do not directly earn a clause. Their job is to make the sentence defensible under skeptic pressure. A recruiter asking “but do you know DSA in C?” gets Rung 3. A recruiter asking “but have you designed a small library?” gets Rung 2. Supporting mass.

What This Ladder Explicitly Does Not Include

Every portfolio has a scope. Naming what’s out is as important as naming what’s in.

  1. A CUDA kernel. Out of scope. If you want CUDA, that’s a separate roadmap after M13. C on the CPU is enough of a moat.

  2. A kernel module or eBPF program. Tempting for signal, but deep enough to be its own quarter of work. 07_applied_c_ml_inference/07_kernel_and_driver_intro.md is intro-only.

  3. A raytracer or graphics engine. Cool. Not on the ML-infra path. Skip.

  4. A C compiler. No. Not in 13 months. Not with a full-time job.

  5. A general-purpose crypto library. Never write your own crypto. Not on any timeline.

If you feel the pull to add any of these, name what you would cut from the seven. That’s the discipline.

Return to README.md · Previous: 02_sprint_calendar.md · Next: 04_weekly_rhythm.md