The Next 13 Months — Month-by-Month

Every month in this file has the same seven fields: Theme · Phase(s) · Sprints · Deliverables · Learning targets · Rung status · Zoho alignment · India-life warnings · Exit check. Read only the current month in full. Skim the rest. Re-read the current month on the first Sunday of that month.

Four buffer weeks are reserved (one per quarter): W7, W20, W33, W52. Do NOT plan work in those weeks. They are for slippage, life, and rest. If a month is on track, use the buffer to breathe. If a month slipped, use the buffer to catch up.

The Valley of Despair: M4 (Oct 2026) → M6 (Jan 2027). Named on purpose. Read 13_discipline/07_motivation_sustainment.md before entering. Read it again on the first day of M5.

M1 — July 2026 (2026-07-06 → 2026-08-05)

  • Theme: Wake the muscle. Toolchain green, syntax back in fingers, first repo public.

  • Phase: Phase 0 (Refresh + Toolchain).

  • Sprints: S1 (W1–W2), S2 (W3–W4).

  • Deliverables:

    • Day 1: everything from 11_tools_setup/01_day1_macos_setup.md installed. clang++ --version reports LLVM 21+. hello.cpp compiles with -std=c++23.

    • W2: 15 syntax-refresh drills from 01_phase_0_refresh_and_toolchain/03_syntax_refresh_drills.md complete, checked in.

    • W3: three tiny projects from 01_phase_0_refresh_and_toolchain/04_first_projects.md (a wc clone, a JSON-line pretty-printer, a tail -f clone) working.

    • W4: Rung 1 published → cpp-refresh-2026 on GitHub with README, CI, three tools, one blog post.

  • Learning targets: compile → link → debug from CLI. clang++, cmake, ninja, lldb, clangd, sanitizers. std::vector, std::string, std::string_view, std::optional, std::span, std::format.

  • Rung status: Rung 1 due W4 (2026-08-02).

  • Zoho alignment: Quiet. No mentions to your manager yet. Q1 is observe, not announce. See 06_background_alignment.md.

  • India-life warnings: Monsoon starts. Power cuts in Chennai/Bangalore possible — invest in a small UPS if your ISP/router is critical Sunday nights. Independence Day long weekend (Aug 15) is a bonus buffer.

  • Exit check:

    • Rung 1 public on GitHub.

    • lab-notebook.md has 20+ entries (one per work-day).

    • You can compile, run, and debug a multi-file C++23 project from a terminal without googling flags.

    • You have opened 02_phase_1_modern_cpp_core/README.md and read it once.

M2 — August 2026 (2026-08-06 → 2026-09-05)

  • Theme: RAII and move semantics — the two ideas that make C++ C++.

  • Phase: Phase 1 (Modern C++ Core).

  • Sprints: S3 (W5–W6), S4 (W7–W8). W7 is buffer — do NOT plan.

  • Deliverables:

    • W5–W6: Ownership + RAII (02_phase_1_modern_cpp_core/01_ownership_and_raii.md), move semantics (02_move_semantics_and_value_categories.md).

    • W6: P1.1 LRU Cache started (spec in 02_phase_1_modern_cpp_core/projects.md).

    • W8: LRU Cache benchmark-honest against std::map-based baseline; TSan clean; 5-min blog post.

  • Learning targets: unique_ptr, shared_ptr, RAII patterns, rule of 0/3/5, l/x/pr-values, guaranteed copy elision, std::move semantics, -Wpessimizing-move.

  • Rung status: Rung 2 (LRU Cache) in flight — due M3 W12.

  • Zoho alignment: Still Q1 quiet. Notice which Zoho codebases you touch have C++ in them (ManageEngine agents? Zoho Meeting? Ulaa? Zia inference services?). Log in a private note, do not act.

  • India-life warnings: Rakhi + Independence Day around Aug 15 — plan for one lost weekend. Heat: keep the M-series MacBook off your lap during long benchmarks.

  • Exit check:

    • You can explain unique_ptr vs shared_ptr vs raw pointer choice for a given situation in <60 seconds.

    • You know why return std::move(x) is now a warned anti-pattern.

    • lab-notebook.md has a “predicted vs measured” entry from the LRU benchmark.

M3 — September 2026 (2026-09-06 → 2026-10-05)

  • Theme: Templates, concepts, STL — the compile-time toolbox.

  • Phase: Phase 1 tail → Phase 2 head (DSA overlap begins W9).

  • Sprints: S5 (W9–W10), S6 (W11–W12).

  • Deliverables:

    • W9–W10: templates + concepts (02_phase_1_modern_cpp_core/03_templates_and_concepts.md), STL deep dive (04_stl_deep_dive.md), error handling with std::expected (05_error_handling_modern.md).

    • W9: start P1.2 JSON parser (spec in Phase 1 projects.md); target completion W10.

    • W11–W12: P1.3 Thread-safe object pool — first taste of concurrency. Cheap teaser for Phase 3.

    • W12: Rung 2 (LRU Cache) published + Rung 3 (Mini JSON) in flight.

    • Phase 2 kickoff W9 — begin daily 30-min DSA habit (see 03_phase_2_dsa_in_cpp/02_neetcode_150_roadmap.md).

  • Learning targets: function templates, class templates, concepts, requires, std::ranges, std::expected, std::flat_map, std::unordered_map vs Abseil flat_hash_map.

  • Rung status: Rung 2 shipped W12. Rung 3 (Mini JSON) started W11 — due M4.

  • Zoho alignment: Q1 continues. If a colleague is working on a C++ codebase, offer to pair-review one PR — no ownership, just observation.

  • India-life warnings: Onam / Ganesh Chaturthi mid-Sep — one lost weekend possible depending on region. Server room monsoon flooding is real; back up your ~/dev to iCloud + Git.

  • Exit check:

    • You can write a concept-constrained template function without SFINAE.

    • Rung 2 on GitHub with green CI badge and README benchmark table (honest, including where you lose).

    • You have solved 15+ NeetCode 150 problems in raw C++ (not Python).

M4 — October 2026 (2026-10-06 → 2026-11-05) ⚠️ VALLEY OF DESPAIR START

  • Theme: DSA in raw C++. This month will hurt. Show up anyway.

  • Phase: Phase 2 (DSA in C++).

  • Sprints: S7 (W13–W14), S8 (W15–W16).

  • Deliverables:

    • W13–W16: Work NeetCode 150 by pattern (03_phase_2_dsa_in_cpp/04_patterns_and_templates.md) — arrays, hashing, two-pointers, sliding window, stacks, binary search, linked list, trees.

    • W14: Rung 3 (Mini JSON) shipped.

    • W16: 60/150 NeetCode problems solved in C++ with GHA CI compiling all committed solutions.

  • Learning targets: STL for competitive (03_phase_2_dsa_in_cpp/01_stl_for_competitive.md), custom data structures (03_custom_data_structures.md), iterator invalidation, common O(n²) accidents.

  • Rung status: Rung 3 shipped W14. Rung 4 (NeetCode 150) in flight — due M5.

  • Zoho alignment: Q2 begins. Measure now. Ask (informally, over coffee) which teams have C++ codebases. Do not propose anything. Just learn the org.

  • India-life warnings: Dussehra + Diwali cluster (variable dates late Oct/early Nov). Plan for 5–7 lost personal-time days across the month. Diwali cleaning + family visits are non-negotiable — this is exactly what the buffer weeks exist for. Air quality drops post-Diwali in Delhi/NCR (fewer relevant for Bangalore/Chennai but still).

  • Valley of Despair reminder: You will feel like you’re not progressing. Templates will feel opaque. DSA will feel slower than it should. This is the month described in 13_discipline/07_motivation_sustainment.md. Re-read it.

  • Exit check:

    • 60/150 NeetCode problems in C++, committed, CI-green.

    • You can pattern-match a problem to a technique (sliding window vs two-pointer vs monotonic stack) inside 60 seconds.

    • You did not quit.

M5 — November 2026 (2026-11-06 → 2026-12-05) ⚠️ VALLEY OF DESPAIR MID

  • Theme: Finish DSA to 100+, cross into systems.

  • Phase: Phase 2 (finish) → Phase 3 (begin).

  • Sprints: S9 (W17–W18), S10 (W19–W20). W20 is buffer.

  • Deliverables:

    • W17–W19: NeetCode to 100+ solutions. Graphs, DP-1, DP-2, backtracking, heaps.

    • W18: begin Phase 3 memory model reading (04_phase_3_systems_and_concurrency/01_memory_model.md) — read on nights DSA is done.

    • W20: Rung 4 (neetcode-150-cpp) published — 100+ problems minimum, GHA compiles all, blog post: “What NeetCode 150 in raw C++ taught me the Python version did not.”

  • Learning targets: graph traversal patterns, DP state design, memoization vs tabulation, monotonic stack/queue, priority-queue idioms, DSA study simulation from 05_interview_simulation.md.

  • Rung status: Rung 4 shipped W20. Rung 5 (Concurrency kit) not yet started.

  • Zoho alignment: Q2 measure continues. By end of M5 you should be able to name the 2–3 Zoho products that have C++ in production and roughly what they do (ManageEngine agents / Zoho Meeting media pipeline / Ulaa / Zia inference).

  • India-life warnings: Wedding season begins (Nov–Feb) — expect 1–2 lost weekends per month for the next 4 months. This is why the calendar has buffer weeks. Do NOT plan a heavy sprint the weekend of a wedding. Bhai Dooj / late-Diwali cleanup can bleed into early Nov.

  • Exit check:

    • Rung 4 published, 100+ solutions in neetcode-150-cpp repo, HN/r/cpp share optional.

    • You have opened 04_phase_3_systems_and_concurrency/README.md and read it.

    • You are still here.

M6 — December 2026 (2026-12-06 → 2027-01-05) ⚠️ VALLEY OF DESPAIR END

  • Theme: Memory model, threads, synchronization. The month C++ becomes systems programming.

  • Phase: Phase 3 (Systems + Concurrency) + Phase 4 (Build tooling begins W21).

  • Sprints: S11 (W21–W22), S12 (W23–W24).

  • Deliverables:

    • W21–W22: memory model (01_memory_model.md), threads + sync (02_threads_and_sync.md).

    • W22: P3.1 SPSC ring buffer — TSan clean, benchmarked within 2× of Boost.Lockfree.

    • W23–W24: begin modern CMake (05_phase_4_build_test_tooling/01_modern_cmake.md), Conan/vcpkg. P4.1 reference C++20 project template — this becomes the skeleton for every future rung.

  • Learning targets: happens-before, std::memory_order, std::atomic, CAS, std::mutex vs std::shared_mutex vs std::scoped_lock, std::jthread + stop_token, modern target-based CMake, Conan 2 manifest mode, vcpkg baseline SHAs.

  • Rung status: Rung 5 (concurrency kit) started W22.

  • Zoho alignment: Q2 continues. Year-end is quiet at most orgs — good month for reading and observation. Do not push any Zoho C++ ownership yet.

  • India-life warnings: Christmas / year-end slowdown at Zoho — extra 2–3 hours/week may free up. Do NOT overspend it; you enter the AI-rebound risk zone (see 99_pre_mortem/02_the_AI_rebound.md) if you go from 15 hrs/wk to 30 abruptly. Cap increase at +5 hrs.

  • Exit check:

    • P3.1 SPSC ring buffer TSan-clean and benchmarked.

    • Reference project template compiles clean with sanitizers on, CI on GHA.

    • You are through the Valley. It gets better from here.

M7 — January 2027 (2027-01-06 → 2027-02-05)

  • Theme: Concurrency finished, applied ML begins. The pivot into your target domain.

  • Phase: Phase 3 (finish) → Phase 5 (begin) → Phase 4 (tooling ongoing).

  • Sprints: S13 (W25–W26), S14 (W27–W28). S13 is buffer sprint.

  • Deliverables:

    • W25: P3.2 Thread pool — 100K tasks < 500ms on M-series.

    • W26: Rung 5 (cpp-concurrency-kit) published — SPSC + thread pool + benchmarks + blog.

    • W27–W28: begin Phase 5 — Eigen (06_phase_5_cpp_for_ml_data/01_eigen_linear_algebra.md).

    • W28: P3.3 minimal event loop on kqueue (Mac). Optional — skip if behind.

  • Learning targets: lock-free basics (04_lock_free_basics.md), std::future/std::async (why to avoid the naive form), coroutines status in 2027 (still library-fragmented), Eigen matrix API, expression templates.

  • Rung status: Rung 5 shipped W26. Rung 6 (mynn-cpp) starts W28.

  • Zoho alignment: Q3 begins. Propose now. Bring a specific idea to your manager — not “let me do more C++” but “our Python model X is hitting inference latency Y; I’ve been sharpening C++ skills and I’d like to prototype a native inference path.” Bring a P5.1 sketch, not a plan document.

  • India-life warnings: Sankranti/Pongal (Jan 14–15). Wedding season still on. Bangalore/Chennai are pleasant this month — the one month you can do outdoor thinking walks.

  • Exit check:

    • Rung 5 shipped with public benchmarks.

    • You have written your first Eigen program that computes a matrix multiply and validated it against NumPy.

    • You have had one honest conversation with your Zoho manager about the C++/ML direction.

M8 — February 2027 (2027-02-06 → 2027-03-05)

  • Theme: Eigen → PyTorch C++ → the pybind11 bridge. The bridge that becomes your job description.

  • Phase: Phase 5 (C++ for ML/Data).

  • Sprints: S15 (W29–W30), S16 (W31–W32).

  • Deliverables:

    • W28–W30: P5.1 Eigen tiny MLP on MNIST — hand-rolled forward + backward, ≥95% test accuracy.

    • W31: P5.2 pybind11 wrap of P5.1 — pip install-able from Test PyPI, matches PyTorch within 1% on same seed.

    • W32: begin ONNX Runtime C++ reading (06_phase_5_cpp_for_ml_data/03_onnx_runtime_cpp.md).

  • Learning targets: Eigen expression templates, backprop by hand, cross-entropy + softmax numerical stability, pybind11 vs nanobind decision (04_pybind11_and_nanobind.md), Python Stable ABI, MPS fallback flag PYTORCH_ENABLE_MPS_FALLBACK=1.

  • Rung status: Rung 6 (mynn-cpp HARD GATE #1) in flight — due M9 W36.

  • Zoho alignment: Q3 continues. If your manager was receptive in M7, this is when you show them P5.1 running. If they weren’t — no problem, you are 4 months from having a public shipped mynn-cpp regardless.

  • India-life warnings: Wedding season ends. Board exams / school stress in the family may add ambient noise. February is short — pace accordingly.

  • Exit check:

    • P5.1 hits ≥95% MNIST accuracy, benchmarked vs. PyTorch on same seed.

    • P5.2 wheel builds on your Mac and installs into a fresh venv.

    • mynn-cpp skeleton on GitHub, private or public.

M9 — March 2027 (2027-03-06 → 2027-04-05) 🟧 HARD GATE #1

  • Theme: Ship the first hard gate. mynn-cpp goes public.

  • Phase: Phase 5 (finish) → Phase 6 (begin).

  • Sprints: S17 (W33–W34), S18 (W35–W36). W33 is buffer.

  • Deliverables:

    • W33–W35: P5.3 ONNX Runtime inference server — HTTP (drogon or httplib), request batching, benchmarks vs FastAPI + PyTorch.

    • W36: P5.4 Arrow pipeline — read 1M-row Parquet, transform, write; ≥5× pandas throughput.

    • W36 (2027-03-31): 🟧 HARD GATE #1 — Rung 6 mynn-cpp published.

      • Public GitHub repo, MIT license.

      • Eigen MLP + pybind11 bindings.

      • MNIST test acc ≥95%.

      • Matches PyTorch ≤1% on identical seed.

      • Wheel published to Test PyPI (pip install --index-url https://test.pypi.org/simple/ mynn-cpp works).

      • README with build instructions, benchmark table, honest limitations.

      • Blog post shared on r/cpp, r/MachineLearning, HN.

  • Miss condition: If hard gate misses by more than 14 days (2027-04-14), enter reset protocol per 99_pre_mortem/05_the_hard_gate_M9_miss.md. 14-day pause, honest re-scope, then continue. Not shame. Protocol.

  • Learning targets: ONNX Runtime C++ API, session options, IO binding, dynamic vs static shapes, Arrow columnar layout, Parquet metadata, arrow::compute kernels.

  • Rung status: Rung 6 hard gate. Rung 7 (mini-inference-cpp) preview starts.

  • Zoho alignment: Q3 pivot. If M7/M8 conversations landed, this is when a Zoho project might be assigned to you — an actual C++ inference component. Take it. If not, mynn-cpp is already better signal externally than any internal project.

  • India-life warnings: Holi around mid-March — one lost weekend. Financial year-end at Zoho — Q4 India fiscal ends March 31. Expect elevated Zoho workload the last 2 weeks. This is the single most dangerous month for Zoho creep interfering with the hard gate. Read 99_pre_mortem/04_the_zoho_creep.md on March 1.

  • Exit check:

    • Rung 6 hard gate: mynn-cpp public, ≥95% MNIST, ≤1% PyTorch delta, Test PyPI wheel, blog live.

    • P5.3 inference server running locally, benchmarked.

    • You believe the M13 pitch is possible.

M10 — April 2027 (2027-04-06 → 2027-05-05)

  • Theme: Production plumbing. gRPC, HTTP, observability, profiling.

  • Phase: Phase 6 (Production Systems).

  • Sprints: S19 (W37–W38), S20 (W39–W40). W40 is buffer.

  • Deliverables:

    • W37–W38: gRPC + Protobuf (07_phase_6_production_systems/01_grpc_and_protobuf.md), Drogon HTTP (02_http_and_web_services.md).

    • W39–W40: begin P6.1 gRPC inference service — layer gRPC on top of P5.3’s ONNX Runtime core.

    • Begin logs/metrics/traces reading (03_logging_metrics_tracing.md) — Prometheus, OpenTelemetry, BatchSpanProcessor (never Simple in prod).

  • Learning targets: gRPC unary + streaming, callback vs completion queue APIs (2027: callback is default for new code), Prometheus C++ client, OpenTelemetry C++ SDK, Grafana dashboard basics.

  • Rung status: Rung 7 (mini-inference-cpp HARD GATE #2) in flight — due M11 W44.

  • Zoho alignment: Q4 begins. Own now. If you have a Zoho C++ project from M9, this is where you deliver a first shippable milestone. Frame it externally: “I shipped a production C++ inference component at Zoho” is a resume-level line.

  • India-life warnings: Tamil New Year / Vishu / Baisakhi mid-April. Summer heat begins — Bangalore/Chennai afternoons drop developer productivity 15–20% (measured effect, not vibes). Move deep-work blocks to mornings if possible.

  • Exit check:

    • gRPC service running locally, streaming inference requests to your ONNX core.

    • Prometheus metrics exposed at /metrics, scraped by a local Prometheus instance.

    • One Grafana dashboard exists.

M11 — May 2027 (2027-05-06 → 2027-06-05) 🟧 HARD GATE #2

  • Theme: Ship the second hard gate. mini-inference-cpp goes public AND deployed.

  • Phase: Phase 6 (finish) → Phase 7 (Capstone + Signal begins).

  • Sprints: S21 (W41–W42), S22 (W43–W44).

  • Deliverables:

    • W41–W42: P6.2 full observability harness — logs (spdlog), metrics (Prometheus), traces (OTel) integrated end-to-end.

    • W43–W44: dynamic batching (Triton-lite in-process), Docker image, deploy to $5/mo VM (Hetzner CX11 €4.51/mo or DigitalOcean droplet).

    • W44 (2027-05-31): 🟧 HARD GATE #2 — Rung 7 mini-inference-cpp published + deployed.

      • Public GitHub repo with README, license, tests, CI.

      • gRPC + REST APIs.

      • ONNX Runtime backend.

      • Dynamic batching.

      • Prometheus metrics + OpenTelemetry traces.

      • Docker image (multi-stage, <200MB).

      • Live URL with 30-day uptime commitment.

      • k6/ghz load tests at c=1/8/32/128 documented.

      • 3 Grafana dashboards (throughput, latency histogram, error rate).

      • Blog post: “Building a production ONNX inference server in 8 weekends.”

  • Miss condition: Miss by more than 14 days (2027-06-14) → reset protocol per 99_pre_mortem/05_the_hard_gate_M9_miss.md (same protocol, different rung).

  • Learning targets: dynamic batching mechanics, request coalescing, tail-latency budgets, p50/p95/p99, tracing sampling strategies, container image minimization, uptime monitoring.

  • Rung status: Rung 7 hard gate. Capstones (Rung 8) start next month.

  • Zoho alignment: Q4 own continues. If you have a Zoho C++ project, aim to demo it internally by end of M11. Public mini-inference-cpp and internal Zoho work reinforce each other: they are proof of the same skill from two sides.

  • India-life warnings: Peak summer. Heat is a real productivity variable — buy a small desk fan, keep MacBook cool during long-running load tests (thermal throttling will corrupt your benchmarks). Ramadan / Eid ul-Fitr around late-May depending on year.

  • Exit check:

    • Rung 7 hard gate: mini-inference-cpp public, deployed, live URL, load-tested, blogged.

    • You can send a curl request to your public URL and get an inference back in <100ms.

    • You start rehearsing the M13 pitch (see 07_thirteen_month_pitch.md).

M12 — June 2027 (2027-06-06 → 2027-07-05)

  • Theme: Capstones. The signal you leave behind.

  • Phase: Phase 7 (Capstone + Signal).

  • Sprints: S23 (W45–W46), S24 (W47–W48).

  • Deliverables:

    • W45–W48: Capstone Alpha miniserve — production-grade ML inference server, patterned on Triton dynamic batching but ONNX-only. Multi-model support, model reload without restart, config-driven, production dashboards.

    • Parallel: begin Capstone Beta pyfast_ann — HNSW-lite ANN index with nanobind bindings. Compare vs faiss on 1M-vector benchmark.

  • Learning targets: Multi-model serving architecture, model versioning, warm/cold cache strategies, nanobind (08_phase_7_capstone_and_signal/), HNSW graph construction, ANN accuracy/latency tradeoffs.

  • Rung status: Rung 8 (both capstones) in flight — due M13.

  • Zoho alignment: Q4 own peaks. Update your LinkedIn (08_phase_7_capstone_and_signal/04_linkedin_and_resume.md). Do not job-search yet. You have one more month.

  • India-life warnings: Monsoon returns. Second anniversary of this plan approaches — mild identity-shift risk (impostor: “am I really doing this?”). You are. The repos exist. Look at them.

  • Exit check:

    • miniserve skeleton on GitHub, README done, first working multi-model demo.

    • pyfast_ann benchmark against faiss producing numbers (even if worse — publish the truth).

    • LinkedIn About section rewritten with M13 pitch language.

M13 — July–August 2027 (2027-07-06 → 2027-08-06)

  • Theme: Finish, publish, pitch.

  • Phase: Phase 7 (finish + signal).

  • Sprints: S25 (W49–W50), S26 (W51–W52). W52 is buffer / celebration.

  • Deliverables:

    • W49–W50: Capstone Alpha miniserve published + deployed — full README, tutorial video (5–10 min screencast), blog post, HN Show HN post.

    • W51: Capstone Beta pyfast_ann published — Test PyPI wheel, benchmark blog, r/cpp + r/MachineLearning + r/Python share.

    • W51–W52: study conversion prep (08_phase_7_capstone_and_signal/05_interview_conversion.md). Rehearse the six pitch versions (07_thirteen_month_pitch.md).

    • 2027-08-06: Fortress complete.

  • Learning targets: Storytelling around your artifacts. The pitch is not a summary of what you did; it is the reason a stranger should care. Read Haseeb Qureshi + patio11 before your first offer call.

  • Rung status: Rung 8 shipped. All 8 rungs public.

  • Zoho alignment: You now have optionality. If Zoho gave you real C++/ML ownership, you have a case for a title/comp adjustment. If they didn’t, you have a portfolio that outranks 90% of the applicant pool for the roles you want.

  • India-life warnings: Independence Day, family. Take at least 3 days fully off between W51 and W52. You earned it. Do not turn W52 into a 30-hour week.

  • Exit check:

    • All 8 rungs public.

    • Two capstones deployed / installable.

    • LinkedIn + resume updated per 08_phase_7_capstone_and_signal/04_linkedin_and_resume.md.

    • You can say the M13 pitch out loud, honestly, in 30 seconds. That is the whole game.

What Most People Get Wrong About This Calendar

They treat the phase overlaps as optional. They are not. The reason DSA starts M3 and not M6 is that DSA is a habit, not a phase. The reason Phase 4 tooling begins in M6 (mid-Phase 3) is that you need it for Phase 5 to be real. If you sequence strictly, Phase 5 hits M10 and the hard gates slide, and the whole calendar collapses. The overlaps are load-bearing.

The second thing they get wrong: they skip the buffer weeks. Buffer weeks (W7, W20, W33, W52) look like waste. They are the difference between a plan that survives Diwali and a plan that collapses in October. Reserve them. Use them for slippage. If you don’t need them for slippage, use them for rest — do not fill them with more work. You will need the rest by M9.

The third thing they get wrong: they measure by month, not by rung. A month with no rung movement is a failed month even if you read three books. A month where a rung ships is a successful month even if you skipped some reading. The rungs are the ground truth.

Return to: README.md · Next: 02_sprint_calendar.md — the 26-sprint calendar with dates.