No waitlist. The work decides.

Ship AI Products in Production

4 milestones · 12 weeks

Ship a real AI-powered product to production and keep it live with real users — proof is usage data and a technical post-mortem, not a tutorial.

First Three Projects Shipped (Beginner to Public App)

5 milestones · 16 weeks

Write, run, and ship your first Python programs — from a terminal hello-world to a deployed web app that real strangers can use.

Build and Deploy Your First Web App

5 milestones · 12 weeks

Build a complete web application — frontend, backend, and deployed to a public URL — that real strangers can use without any instructions from you.

Master Python for Real Projects

5 milestones · 12 weeks

Write Pythonic code, work with APIs and external libraries, build and test a data pipeline, and publish a real Python package on PyPI.

Make Your First Open Source Contribution

3 milestones · 6 weeks

Get a pull request merged into a public GitHub repository with 100+ stars.

Ship an AI Product to Real Users

4 milestones · 10 weeks

Take an AI feature or product from working demo to 10 active users outside your network. Proven by real usage data, not by the code shipping.

Master Statistics for Data Analysis

5 milestones · 10 weeks

Apply descriptive statistics, hypothesis testing, regression, and A/B test design to real datasets — every milestone requires working with real data and documenting the decisions, not just the calculations.

Operate as a Staff Engineer

5 milestones · 20 weeks

Staff Engineer is the most misunderstood title in the industry. Many companies hand out the title for tenure or as a retention tool, without the person ever doing Staff-level work. This outcome's proof standard is about the WORK, not the title — every milestone tests for influence without authority, the hardest skill at this level. The defining shift from Senior to Staff is scope: a Senior engineer is excellent within a defined problem. A Staff engineer identifies which problems matter before anyone assigns them, and influences outcomes across teams they do not manage.

Master Rust (Beginner to Systems Project)

0 milestones · 12 weeks

Write, test, and publish a Rust project that demonstrates ownership, lifetimes, and safe concurrency.

Build a Distributed System

0 milestones · 16 weeks

Design and implement a distributed system with consensus, fault tolerance, and observable performance characteristics.

Master System Design (Senior Level)

0 milestones · 12 weeks

Design 10 production-grade systems from scratch, covering scalability, reliability, and trade-offs — peer-reviewed by senior engineers.

Apply Discrete Mathematics Through Formal Proofs

0 milestones · 8 weeks

Produce written solutions to 30+ proof exercises spanning propositional logic, mathematical induction, graph theory, and combinatorics — not just correct answers, but proofs with valid structure (base case, inductive step, conclusion) that a mathematician would accept. Each proof must show your reasoning, not just the result. Proof: the submitted exercise set reviewed by a CS lecturer or maths researcher who also presents 2–3 unseen claims during the review and asks you to prove or disprove them live — the live reasoning is what demonstrates understanding rather than memorisation.

Understand Computer Architecture by Building Below the Language

0 milestones · 10 weeks

Build a working assembler, simple CPU emulator, or cache simulator from scratch — the artifact must demonstrate that you understand what happens below the programming language you normally use: instruction encoding, pipeline stages, cache line behaviour, or memory hierarchy trade-offs. The implementation must be accompanied by a written explanation of every design decision in terms of the specific hardware constraint it addresses. Proof: the working implementation and write-up reviewed by a CS lecturer or systems engineer who traces the execution of a program they haven't shown you through your implementation and asks you to explain every step.

Implement an OS Component to Prove Systems Understanding

0 milestones · 10 weeks

Implement a working process scheduler, memory allocator, or file system component from scratch, accompanied by a written trade-off analysis comparing your design choice against at least two alternatives (e.g. preemptive vs. cooperative scheduling; paging vs. segmentation; linked-list vs. buddy allocator). The analysis must explain the specific workloads under which your choice outperforms alternatives and the specific conditions under which it does not. Proof: the implementation and analysis reviewed by a CS lecturer or systems engineer who asks 'what would happen to your scheduler if you had 1000 threads all waiting on the same lock?' — you must answer using your implementation, not a generic description.

Demonstrate Network Understanding Through Traffic Analysis and Implementation

0 milestones · 8 weeks

Capture real network traffic from your own machine using Wireshark (your IP address must be visible in the capture file), implement a working TCP client/server from scratch using raw sockets (not a framework), and write a report explaining how your specific captured traffic maps to each layer of the protocol stack. The report must explain what each packet header field means in the context of your capture — not as a textbook definition. Proof: the capture file, the working code, and the report reviewed by a CS lecturer or network engineer who provides a previously-unseen packet capture and asks you to diagnose what is happening at each protocol layer.

Implement Core Data Structures From Scratch with Complexity Analysis

0 milestones · 6 weeks

Implement a linked list, binary search tree, hash table, min-heap, and adjacency-list graph from scratch in any language — no library primitives for the core data structure logic. Each implementation must include a full test suite covering edge cases and a documented time and space complexity analysis explaining why each operation has the stated complexity (not just stating it). Proof: the implementations and analysis reviewed by a CS lecturer or senior software engineer who asks 'why is your hash table O(1) amortised for insertion rather than O(1) worst-case?' — you must answer by pointing to your specific implementation and the conditions that trigger rehashing.

Implement 10 Classic Algorithms with Written Complexity Analysis

0 milestones · 6 weeks

Implement 10 classic algorithms from scratch — spanning at least three of: sorting (merge, quick, heap), graph traversal (BFS, DFS, Dijkstra, A*), dynamic programming (LCS, knapsack, edit distance), and string algorithms (KMP, Rabin-Karp). Each implementation must include a written complexity analysis documenting the best, average, and worst-case time and space complexity with a brief explanation of the dominant operations, and documented trade-offs against at least one alternative algorithm. Proof: the implementations and analyses reviewed by a CS lecturer or senior engineer who provides a novel input case you haven't tested and asks you to predict your algorithm's behaviour before running it.

Prove Algorithm Correctness Using Formal Methods

0 milestones · 8 weeks

Write formal correctness proofs for 5 of your algorithm implementations using loop invariants, structural induction, or reduction to a known problem. Each proof must include: the invariant or inductive hypothesis, the proof that it holds at initialisation, the proof that it is maintained through each iteration or recursive step, and the proof that it implies the postcondition. Proof: the written proofs reviewed by a CS lecturer or engineer with formal methods background who asks you to prove correctness for a sixth algorithm you haven't prepared — you must apply your chosen proof technique to the new algorithm during the review session.

Achieve a Verified Competitive Programming Rating

0 milestones · 12 weeks

Reach Codeforces rating 1400+ OR achieve a LeetCode contest rating placing you in the top 25% of contest participants — with your public profile URL as proof. The rating is your proof: it is earned by solving unseen algorithmic problems under time pressure in real contests, and the public rating history with contest participation timestamps cannot be fabricated retroactively. Codeforces rating 1400 corresponds to solving Division 2 A and B problems consistently. LeetCode top 25% corresponds to solving medium-difficulty problems reliably within contest time. Either platform qualifies; both alternatives appear on the same profile URL.

Derive the Linear Algebra Behind Machine Learning

0 milestones · 8 weeks

Produce hand-derived solutions to 20 exercises spanning matrix operations (multiplication, inversion, transposition), eigendecomposition, singular value decomposition, and PCA derivation — all derivations must be symbolic or hand-worked (no NumPy for the derivation steps, only for verification afterwards). The work must show the derivation reasoning, not just the result. Proof: the solutions reviewed by a maths lecturer or ML researcher who presents 2–3 unseen problems during the review session — you must work through them live and explain your reasoning at each step, not just produce an answer.

Apply Statistical Learning Theory to Your Own Dataset

0 milestones · 10 weeks

Document the bias-variance trade-off, model selection using cross-validation, and hypothesis testing applied to a dataset you collected yourself — not a pre-built Kaggle dataset. Your write-up must explain your data collection methodology, the specific modelling decisions you made and why, and the statistical tests you ran to validate each decision. Using your own data is the proof standard: it means the analysis cannot be pre-generated from a known dataset. Proof: the write-up and dataset reviewed by a statistician or ML practitioner who asks 'what would your cross-validation results look like if you doubled the number of folds?' — you must answer using your specific data and analysis, not the general principle.

Implement Machine Learning Algorithms From Scratch (NumPy Only)

0 milestones · 10 weeks

Implement logistic regression, a decision tree, k-means clustering, and a feedforward neural network from scratch using NumPy only — no PyTorch, TensorFlow, or sklearn for the core algorithm logic. Each implementation must be tested on a held-out dataset and benchmarked against the equivalent sklearn implementation on the same data, with documented results explaining any performance differences. The from-scratch implementation is what demonstrates understanding: it is possible to use sklearn without understanding gradient descent; it is not possible to implement gradient descent in NumPy without understanding it. Proof: the implementations reviewed by an ML engineer or CS researcher who provides a different dataset and asks you to predict which of your algorithms will perform best and why — you must reason from your implementation, not just run it.

Implement a Transformer Component From a Published Paper Specification

0 milestones · 12 weeks

Implement a core transformer component — attention mechanism, positional encoding, or byte-pair encoding tokenizer — directly from the specification in a published paper (Attention Is All You Need, or equivalent). The implementation must faithfully replicate the paper's equations in code with comments linking each line of code to the specific equation or paragraph in the paper it implements. Write-up must explain every design decision in terms of the specific constraint or property in the paper that motivated it. Proof: the implementation and write-up reviewed by an ML researcher or senior ML engineer who asks 'what would change in your attention output if you doubled the number of heads but kept the total dimension constant?' — you must answer by reasoning through your specific implementation.

Implement a Cipher From Mathematical Specification and Analyse a Real Vulnerability

0 milestones · 8 weeks

Implement a symmetric cipher (AES, ChaCha20, or equivalent) from its published mathematical specification — no library calls for the core cipher operations, only for testing correctness against known test vectors. Additionally, write an analysis of one published cryptographic vulnerability (a CVE with a known mathematical weakness such as padding oracle, timing side-channel, or nonce reuse) explaining the exact mathematical flaw exploited and how the implementation deviated from the secure specification. Proof: the implementation and vulnerability analysis reviewed by a security practitioner or CS lecturer with cryptography background who presents a different cipher specification you haven't seen and asks you to implement the key schedule or identify the flaw in a published attack — you must engage with the new material in real time, not describe your prepared examples.