Back to Hub
Progress: 0%
DocNest: patterns · Algorithms Coach
FAANG-level curriculum
Full-Stack MasteryFrom "I can code" → "I can design & ship production systems"
A 12-week intensive curriculum designed by engineers, for engineers. Build real projects, harden them for production, and leave with stronger interview and portfolio proof.
Nova · The goal
I want to build production-grade systems and ace FAANG interviews. Show me the path.
Atlas · The strategy
We’ll build incrementally: monolith → harden → scale. Every week ships something real and teaches a core principle.
Atlas · The outcome
By Week 12, you’ll have a portfolio of production apps and the confidence to design systems at any scale.
Fundamentals: Core 12 Skills (C/C++ Route)
Master the core before you specialize
This is the foundation every engineer needs: C for understanding the machine, C++ for abstraction at scale, and the professional habits that make you reliable in any stack.
Skill 1
C: The Mother Tongue of Systems
- •Compilation pipeline: preprocess, compile, link
- •Pointers, memory layout, stack vs heap
- •Core C standard library (stdio, stdlib, string)
- •Undefined behavior and defensive coding
Outcomes
- •Explain how source code becomes an executable.
- •Write small memory-safe C programs with explicit allocation and cleanup.
Knowledge checks
- •What changes between preprocessing, compilation, and linking?
- •What is the difference between stack and heap allocation?
Build: Build a small CLI that allocates, inspects, and frees memory safely.
+140 XP
Skill 2
Locked
Modern C++ Core (The C++ Route)
- •RAII, ownership, and resource management
- •Classes, templates, and STL containers
- •Move semantics and smart pointers
- •Zero-cost abstractions and design tradeoffs
Outcomes
- •Use RAII and smart pointers to model ownership clearly.
- •Reach for STL containers and templates without hiding performance tradeoffs.
Knowledge checks
- •When should ownership live in a smart pointer versus a stack object?
- •What does move semantics save you from copying?
Build: Implement a C++ utility library with tests and benchmarks.
+150 XP
Skill 3
Locked
Data Structures From Scratch
- •Arrays, linked lists, stacks, queues
- •Trees, tries, and hash tables
- •Memory ownership patterns in C/C++
- •API design for reusable data structures
Outcomes
- •Implement reusable data structures with a clean public API.
- •Choose ownership and mutation patterns intentionally instead of accidentally.
Knowledge checks
- •Why is API design as important as internal implementation here?
- •Which data structures benefit most from explicit ownership rules?
Build: Build a generic DS kit in C/C++ with a clean header API.
+160 XP
Skill 4
Locked
Algorithms and Complexity
- •Big-O analysis and practical tradeoffs
- •Sorting and searching (quick/merge/binary)
- •Recursion, iteration, and dynamic programming
- •Benchmarking and input sizing
Outcomes
- •Compare algorithms using both asymptotic and practical performance.
- •Use benchmarking to validate assumptions instead of guessing.
Knowledge checks
- •When does a better Big-O result still lose in practice?
- •How do you choose a representative benchmark input?
Build: Create a sorting lab and compare algorithm performance.
+160 XP
Skill 5
Locked
Operating Systems Fundamentals
- •Processes, threads, and scheduling basics
- •Syscalls and POSIX APIs
- •Memory management and virtual memory
- •Concurrency hazards: races and deadlocks
Outcomes
- •Describe how processes, threads, and memory management interact.
- •Spot race conditions and deadlock risks earlier in design.
Knowledge checks
- •What changes when work moves from one process to many threads?
- •Why are races often harder to reproduce than syntax bugs?
Build: Build a tiny shell with job control and a thread pool.
+180 XP
Skill 6
Locked
File I/O and Data Formats
- •File descriptors, buffering, and streams
- •Binary vs text formats and serialization
- •Parsing and validation strategies
- •Error handling and recovery paths
Outcomes
- •Read and write structured data with stronger validation and error handling.
- •Choose file and serialization formats based on real access patterns.
Knowledge checks
- •What makes binary formats faster but harder to inspect?
- •How do you recover safely from partial or malformed input?
Build: Write a fast log parser with a binary index.
+150 XP
Skill 7
Locked
Networking Fundamentals
- •TCP vs UDP and socket primitives
- •HTTP request/response lifecycle
- •Concurrency models for servers
- •Timeouts, retries, and reliability
Outcomes
- •Build simple network services with clearer reliability assumptions.
- •Explain retries, idempotency, and timeout behavior using real examples.
Knowledge checks
- •When is TCP the right choice over UDP?
- •Why can retries create duplicate work if you ignore idempotency?
Build: Build a minimal HTTP server in C/C++ with routing.
+170 XP
Skill 8
Locked
Tooling, Debugging, and Profiling
- •GDB/LLDB workflows and breakpoints
- •Valgrind and sanitizers
- •Profiling CPU and memory hot spots
- •Logging strategies for systems code
Outcomes
- •Use debuggers and sanitizers as first-class tools instead of last resorts.
- •Produce evidence-driven profiling notes that explain where time or memory goes.
Knowledge checks
- •When should you reach for a debugger versus extra logging?
- •What kind of bugs do sanitizers expose well?
Build: Hunt memory bugs, then publish a profiling report.
+140 XP
Skill 9
Locked
Build Systems and Linking
- •Make and CMake fundamentals
- •Static vs shared libraries
- •Compiler flags and optimization levels
- •Cross-platform build hygiene
Outcomes
- •Ship repeatable builds with consistent flags, tests, and dependency layout.
- •Explain the difference between compiling, archiving, and linking.
Knowledge checks
- •When do you prefer static libraries over shared libraries?
- •Which build details most often break portability?
Build: Ship a multi-target build with unit tests and CI.
+150 XP
Skill 10
Locked
Professional Engineering Practice
- •Git workflows and code review hygiene
- •Testing strategy: unit, integration, regression
- •Design docs and tradeoff communication
- •Security basics: input validation and secrets
Outcomes
- •Write engineering notes and reviews that make your tradeoffs legible to others.
- •Use testing and security basics as part of day-to-day delivery, not only before launch.
Knowledge checks
- •What should every small design note include?
- •Why is input validation still a systems concern?
Build: Release a small library with README, tests, and versioning.
+150 XP
Skill 11
Locked
Linux, Shell, and Automation
- •Shell navigation, pipes, and redirection
- •Process inspection and environment variables
- •Simple automation with scripts and cron-like thinking
- •Using CLI tooling to accelerate debugging and delivery
Outcomes
- •Move faster in the terminal without depending on GUI shortcuts.
- •Automate repetitive engineering tasks with small scripts.
Knowledge checks
- •What problem do pipes solve well in daily engineering work?
- •When is a script better than repeating a command manually?
Build: Automate a local build-and-test workflow with shell scripts and logging.
+160 XP
Skill 12
Locked
Security and Reliability Basics
- •Threat modeling and trust boundaries
- •Secrets management and least privilege
- •Backups, recovery paths, and rollback planning
- •Rate limiting, audit logs, and incident hygiene
Outcomes
- •Spot obvious security and reliability gaps before production discovers them for you.
- •Design safer rollout and recovery plans for small systems.
Knowledge checks
- •What is the first trust boundary in the system you are building?
- •Why are backups useless without restore practice?
Build: Harden a small service with secrets handling, audit logs, and a rollback checklist.
+180 XP
Daily Battle Plan (Bismillah)
Repeat weekly, sharpen daily
A smart daily loop: build the core, train the patterns, and ship. Mark each day complete to keep momentum.
Day 1
C/C++ Core Mechanics
- •Pointers, memory layout, and ownership
- •RAII and smart pointers
- •Write and read low-level code
Build: Drill: implement a vector, then profile for leaks.
+80 XP
Day 2
Locked
DSA Pattern Combat
- •Two pointers or sliding window
- •Hash maps and frequency counting
- •Time/space tradeoffs
Build: Drill: solve 3 problems under 60 minutes.
+90 XP
Day 3
Locked
OS and Concurrency
- •Processes, threads, and synchronization
- •Race conditions and deadlocks
- •Context switching intuition
Build: Drill: build a thread pool and benchmark it.
+90 XP
Day 4
Locked
Networking and Protocols
- •Sockets, TCP lifecycle, and timeouts
- •HTTP request/response anatomy
- •Retries and idempotency
Build: Drill: build a tiny HTTP server with routing.
+90 XP
Day 5
Locked
Tooling and Debugging
- •GDB/LLDB breakpoints
- •Sanitizers and valgrind
- •Profiling hot paths
Build: Drill: fix a crash and write a postmortem.
+80 XP
Day 6
Locked
Build and Ship
- •CMake or Makefile basics
- •Unit tests and CI mindset
- •Release notes and versioning
Build: Drill: ship a small feature with tests.
+90 XP
Day 7
Locked
Review and Interview Simulation
- •Error logs and lessons learned
- •Tradeoff storytelling
- •System design warmup
Build: Drill: 1 mock interview + 1 system design sketch.
+100 XP
Practice Lab: Live Coding Drills
Write code, run tests, fix mistakes
Jump into live drills with test feedback and a mistake library so you avoid the most common wrong turns.
Start Practice LabEngineering Workflow Lifecycle
Learn how real code moves from a laptop to a safe release: local Git, GitHub collaboration, branch policy, testing, CI, CD, and rollback-ready delivery.
1. Local development
Edit, run, debug, and understand what counts as “working locally.”
2. Local Git
Use status, diff, add, commit, log, and branches to track change safely.
3. GitHub collaboration
Push branches, open pull requests, review code, and coordinate as a team.
4. Team policy
Define branch protection, review rules, merge policy, and change expectations.
5. Tests and CI
Use unit, integration, E2E, lint, and build checks to protect the main branch.
6. CD and release
Deploy, stage, release, monitor, and rollback changes with less risk.
Boss Fights (Checkpoints)
Prove the level, unlock the next wave
These checkpoints demand real execution. Complete the prerequisites, then earn the badge.
Boss Fight 1
Locked
Foundations Trial
- •C/C++ fundamentals applied under pressure
- •Data structures implementation review
- •Explain tradeoffs in plain language
Build: Checkpoint: implement a DS, profile it, and defend design choices.
+300 XP
Boss Fight 2
Locked
Systems Trial
- •OS + networking mental models
- •Concurrency with real constraints
- •Debugging and incident response
Build: Checkpoint: build a threaded HTTP server with a postmortem.
+350 XP
Boss Fight 3
Locked
Production Trial
- •System design tradeoffs at scale
- •Testing strategy and release hygiene
- •Operational readiness checklist
Build: Checkpoint: present a design review with risks and mitigation.
+400 XP
Role Tracks: Choose Your Route
Locked until Fundamentals + Battle Plan are complete
Choose the path that matches your target role: frontend, backend, AI, SDE, data, or DevOps. Each track is sequential, and each stage builds on the one before it.
These sequences are grounded in real delivery situations and aligned to official platform documentation patterns for frontend, backend, and AI engineering.
Why it’s locked: advanced frontend, backend, and AI work still depends on the core. Without fundamentals, daily drills, and knowledge checks, later topics collapse under pressure. We lock the path to protect your mastery, confidence, and long-term speed.
Frontend Engineer Route
UI architecture, design systems, visual language, performance, and production frontend delivery.
Stage 1
Locked
Frontend Foundations
- •Semantic HTML
- •CSS layout systems
- •Responsive design
- •Accessibility basics
Real-world scenario
A startup needs a marketing site and product dashboard shell that must load cleanly on mobile, pass basic accessibility review, and be maintainable by a small team.
Outcomes
- •Ship clean, semantic interfaces that work well on desktop and mobile.
- •Use layout, spacing, and accessibility as first-class frontend concerns.
Knowledge checks
- •What breaks first when a layout moves from desktop to mobile?
- •Why does semantic structure matter for accessibility and maintainability?
Definition of done
- •Page uses semantic sections, accessible headings, and keyboard-visible focus states.
- •Layout remains readable on a narrow mobile viewport without content collisions.
- •Reusable shell components can support a second page without duplication.
Build: Build a polished landing page and a reusable dashboard shell.
+220 XP
Stage 2
Locked
Design Systems in Practice
- •Design tokens
- •shadcn/ui composition
- •IBM Carbon governance
- •Pattern reuse across pages
Real-world scenario
The team needs a UI system that moves fast enough for startup work but stays consistent enough to support a growing product and shared ownership.
Outcomes
- •Choose a design system approach that fits team size, speed, and product scope.
- •Turn one-off UI choices into reusable component and token rules.
Knowledge checks
- •Why might a small startup choose shadcn/ui differently from a large enterprise team using Carbon-style governance?
- •Which product decisions should become design tokens instead of ad hoc values?
Definition of done
- •The design system approach is justified with team and product constraints.
- •At least one screen is rebuilt with reusable primitives and tokens.
- •Another engineer can describe when to reuse, extend, or reject a component pattern.
Build: Design a component system strategy and rebuild one surface using reusable tokens and shared patterns.
+240 XP
Stage 3
Locked
Visual Language and Interface Audits
- •Typography scale
- •Spacing rhythm
- •Icons + stroke systems
- •Studying other websites critically
Real-world scenario
The UI looks almost right, but each page was designed in isolation and the product now feels visually inconsistent compared with stronger public-facing websites.
Outcomes
- •Explain why visual consistency affects clarity, trust, and implementation speed.
- •Create a reusable visual system for typography, spacing, icons, and borders.
Knowledge checks
- •What happens when icons, borders, and illustrations use inconsistent stroke weights?
- •How do you study another website without blindly copying it?
Definition of done
- •Visual language includes concrete rules for type, spacing, radius, icon style, and stroke weight.
- •Website audits produce reusable design rules rather than screenshots with vague opinions.
- •A second screen can be designed using the same system without inventing new visual rules.
Build: Audit three real interfaces and turn your findings into a visual language guide with spacing, type, icon, and stroke rules.
+255 XP
Stage 4
Locked
React, State & Product UX
- •Component composition
- •State management
- •Forms + validation
- •Data fetching patterns
Real-world scenario
Your product team ships an onboarding flow with async data, multi-step forms, validation, and several user states that must remain understandable under failure conditions.
Outcomes
- •Model frontend state intentionally instead of scattering state across components.
- •Build flows that stay usable across loading, success, and error states.
Knowledge checks
- •When should state stay local and when should it move higher?
- •What makes a form feel trustworthy instead of fragile?
Definition of done
- •Flow handles loading, success, empty, and error states without confusing the user.
- •Validation exists both in the UI and at the form submission boundary.
- •State transitions are simple enough that another engineer can trace them quickly.
Build: Build a multi-step product flow with forms, validation, and async data states.
+270 XP
Stage 5
Locked
Frontend Performance & Quality
- •Rendering performance
- •Code splitting
- •Testing strategy
- •Release confidence
Real-world scenario
A dashboard feels slow in production, bundle size has grown, and the UI is starting to drift because teams are building one-off components instead of shared patterns.
Outcomes
- •Diagnose slow renders and bundle problems with evidence.
- •Build component systems that scale without visual drift.
Knowledge checks
- •What causes a component tree to rerender too often?
- •How do design systems reduce both bugs and design inconsistency?
Definition of done
- •You can point to measured performance improvements rather than subjective claims.
- •Critical UI components share tokens, patterns, and predictable APIs.
- •Key user flows have frontend tests that protect against regressions.
Build: Audit and optimize a frontend app for performance, consistency, and test coverage.
+260 XP
Stage 6
Locked
Production Frontend Platform
- •Auth UX
- •Observability
- •Edge delivery
- •Analytics + experimentation
Real-world scenario
The frontend is live, but the team still needs safe rollout practices, auth edge cases, analytics, and enough telemetry to know whether the release actually works in production.
Outcomes
- •Treat delivery, measurement, and reliability as part of frontend engineering.
- •Launch interfaces with stronger instrumentation and rollback thinking.
Knowledge checks
- •What signals tell you a frontend release is actually healthy?
- •How should a frontend team think about rollback safety?
Definition of done
- •Critical auth flows, experiments, and analytics events are instrumented and reviewable.
- •Release plan includes rollback or feature-flag fallback, not just deployment.
- •Monitoring can distinguish frontend failure, API failure, and content failure.
Build: Ship a production frontend with auth flows, monitoring, analytics, and rollout safety.
+300 XP
Backend Engineer Route
APIs, data systems, indexing, monitoring, reliability, and secure service design at production depth.
Stage 1
Locked
Runtime, HTTP, and Service Boundaries
- •Node runtime model
- •HTTP contracts
- •Validation
- •Service ownership boundaries
Real-world scenario
A product squad needs a backend for accounts, records, and workflows. The API must be easy to consume, the runtime behavior must stay predictable, and input cannot be trusted.
Outcomes
- •Model runtime and API behavior clearly enough for other teams to consume safely.
- •Build backend features with cleaner validation and service boundaries.
Knowledge checks
- •Why should a backend engineer understand the runtime before designing service behavior?
- •Why should validation exist at the system boundary instead of only in the UI?
Definition of done
- •API handlers validate requests, return consistent responses, and map clearly to service boundaries.
- •Startup configuration and request validation fail safely instead of silently.
- •A second engineer could consume the service without reverse-engineering the contract.
Build: Design and build a backend service with clear HTTP contracts, startup validation, and explicit ownership boundaries.
+220 XP
Stage 2
Locked
Data Modeling and Query Design
- •Schema design
- •Database access patterns
- •Relationships
- •Query tradeoffs
Real-world scenario
A product squad is adding features quickly, and the backend schema must stay coherent as records, workflows, and reports grow more complex.
Outcomes
- •Model data clearly enough that queries and APIs stay understandable.
- •Choose schema boundaries based on access patterns instead of vague intuition.
Knowledge checks
- •When is the schema telling you the product model is unclear?
- •Which query patterns should shape the schema earliest?
Definition of done
- •Key entities and access patterns are documented together.
- •Data model supports the product workflow without ambiguous ownership.
- •Another engineer can explain why the schema fits the use case.
Build: Model a real product domain with entities, relationships, and the main queries the system must support.
+240 XP
Stage 3
Locked
Database Indexing and Performance Paths
- •Indexes
- •Query plans
- •Selectivity
- •Read/write tradeoffs
Real-world scenario
A query that worked fine at startup volume is now one of the slowest endpoints in production because the storage path no longer matches the way users read data.
Outcomes
- •Reason about query performance using indexes and plans instead of guesswork.
- •Explain why read optimization changes write cost and operational tradeoffs.
Knowledge checks
- •What access pattern makes an index worthwhile?
- •Why can too many indexes hurt write-heavy systems?
Definition of done
- •A slow query is tied to an explicit indexing decision.
- •The tradeoff between performance and maintenance overhead is explained clearly.
- •The learner can describe what a query plan is telling them at a practical level.
Build: Profile a slow query, propose an index strategy, and justify the tradeoffs using realistic access patterns.
+255 XP
Stage 4
Locked
Auth, Caching & Async Workflows
- •Authentication
- •Authorization
- •Caching strategies
- •Queues + background jobs
Real-world scenario
Traffic is growing, some operations are expensive, and security-sensitive endpoints need stronger control over who can do what and when heavy jobs should move off the request path.
Outcomes
- •Choose the right mechanism for protected access and expensive work.
- •Use queues and caching to improve latency without losing correctness.
Knowledge checks
- •What should stay synchronous and what should move to background work?
- •Which cache invalidation strategy matches the consistency requirement?
Definition of done
- •Protected endpoints enforce both authentication and authorization rules.
- •At least one expensive flow is moved to async processing with visible latency improvement.
- •Cache behavior and invalidation policy are documented, not implicit.
Build: Add auth, caching, and async job processing to a service with measurable gains.
+275 XP
Stage 5
Locked
Observability, Monitoring & SLOs
- •Metrics, logs, traces
- •Monitoring systems
- •SLIs + SLOs
- •Alerting discipline
Real-world scenario
The backend has become business-critical, and incidents now involve noisy alerts, partial failures, and unclear root causes across service boundaries.
Outcomes
- •Instrument systems so incidents are diagnosable under pressure.
- •Define monitoring signals that map to real user impact instead of vanity metrics.
Knowledge checks
- •What makes an alert actionable enough to wake someone up?
- •Which telemetry helps you identify a backend bottleneck fastest?
Definition of done
- •Metrics, logs, and traces make at least one failure mode diagnosable end to end.
- •At least one SLO is written in concrete terms and tied to a user-facing outcome.
- •The monitoring plan distinguishes useful pages from low-signal noise.
Build: Instrument a service, define health signals, and build a monitoring plan with actionable alerts.
+295 XP
Stage 6
Locked
Security, Reliability & Service Ownership
- •Threat modeling
- •Rate limiting
- •Runbooks + on-call
- •Capacity planning
Real-world scenario
The backend is now business-critical, so the team needs more than code correctness: threat awareness, abuse protection, recovery plans, and service ownership practices.
Outcomes
- •Own a backend service end to end, including operational and security responsibilities.
- •Communicate service risks and mitigations clearly before launch.
Knowledge checks
- •Where is the highest-risk trust boundary in your service?
- •What does readiness look like beyond passing tests?
Definition of done
- •Threat model, rate limits, and abuse controls are documented for the service.
- •Runbook includes alert triage, rollback, and recovery steps.
- •Capacity and failure assumptions are written down and reviewable before release.
Build: Ship a production backend with runbooks, threat model, load strategy, and rollback plan.
+320 XP
SDE Route
End-to-end product delivery with strong backend and system design fundamentals.
Stage 1
Locked
Full-Stack Core
- •HTTP + REST APIs
- •Auth + data modeling
- •Frontend state + UX
- •Testing basics
Build: Build a full-stack feature with auth, CRUD, and tests.
+220 XP
Stage 2
Locked
Backend Depth
- •Caching + queues
- •Observability + logs
- •Error handling + retries
- •Performance profiling
Build: Add caching, background jobs, and metrics to a service.
+240 XP
Stage 3
Locked
Scaling & System Design
- •Load balancing
- •Data partitioning
- •Consistency tradeoffs
- •Capacity planning
Build: Design a scalable feed service with tradeoffs.
+260 XP
Stage 4
Locked
Capstone Delivery
- •Deploy + monitor
- •Feature flags + rollbacks
- •Runbooks + SLAs
Build: Ship a production-grade app with rollout and rollback plans.
+300 XP
SDE II Route
Distributed systems depth, reliability leadership, and architecture reviews.
Stage 1
Locked
Distributed Systems Depth
- •Replication
- •Leader election
- •Consistency models
- •Failure modes
Build: Write a design note for a replicated service.
+260 XP
Stage 2
Locked
Performance & Cost
- •Latency budgets
- •Caching layers
- •Profiling
- •Cost modeling
Build: Optimize a service and document cost savings.
+280 XP
Stage 3
Locked
Reliability Engineering
- •SLOs + error budgets
- •Incident response
- •Chaos testing
- •Postmortems
Build: Run a game day with a postmortem report.
+280 XP
Stage 4
Locked
Technical Leadership
- •Design docs
- •Mentoring
- •Cross-team reviews
- •Roadmapping
Build: Lead a design review and deliver sign-off notes.
+300 XP
Data Engineer Route
Data pipelines, warehousing, and reliability at scale.
Stage 1
Locked
SQL + Data Modeling
- •Star schema
- •Normalization
- •Indexes
- •Data contracts
Build: Model a product analytics schema and queries.
+220 XP
Stage 2
Locked
Batch ETL
- •Pipelines
- •Idempotency
- •Scheduling
- •Validation
Build: Build a batch pipeline with tests and monitoring.
+240 XP
Stage 3
Locked
Streaming + Warehousing
- •Event ingestion
- •Stream processing
- •Partitioning
- •Warehouses
Build: Ingest events into a warehouse with SLAs.
+260 XP
Stage 4
Locked
Data Quality & Governance
- •Lineage
- •Access control
- •Quality checks
- •Cost + SLAs
Build: Ship quality checks and a data reliability dashboard.
+280 XP
Data Science Route
Statistics, modeling, and deployment with real-world rigor.
Stage 1
Locked
Python + Statistics
- •Pandas + EDA
- •Distributions
- •Hypothesis testing
- •Visualization
Build: Analyze a dataset and publish insights.
+220 XP
Stage 2
Locked
ML Fundamentals
- •Feature engineering
- •Train/test split
- •Baseline models
- •Bias/variance
Build: Train a baseline classifier with metrics.
+240 XP
Stage 3
Locked
Evaluation & Experimentation
- •Metrics
- •Cross-validation
- •A/B testing
- •Data leakage
Build: Design an evaluation plan with guardrails.
+260 XP
Stage 4
Locked
Deployment & Monitoring
- •Model serving
- •Drift detection
- •Monitoring
- •Rollbacks
Build: Deploy a model with monitoring and alerts.
+280 XP
AI Engineer Route
AI evolution, compute, tokens, model selection, agent workflows, productivity design, and AI product delivery with engineering rigor.
Stage 1
Locked
AI Evolution and System Framing
- •Symbolic AI vs ML
- •Deep learning to foundation models
- •AI product systems
- •Why history matters
Real-world scenario
Students are using AI tools daily but cannot explain the difference between AI, ML, deep learning, LLMs, or what an AI product actually contains beyond a model call.
Outcomes
- •Explain the major eras of AI without collapsing them into one vague category.
- •Describe an AI feature as a system with model, context, tools, and safeguards.
Knowledge checks
- •What changed when the field moved from hand-written rules to data-driven models?
- •Why is an AI product more than an API call to a model?
Definition of done
- •Learner can distinguish symbolic AI, ML, deep learning, and LLM systems clearly.
- •The feature is explained as a full system rather than a single prompt.
- •Historical framing reduces hype and improves technical precision.
Build: Create a timeline and system map that explains how AI evolved and what components a modern AI product needs.
+240 XP
Stage 2
Locked
AI Chips, Compute, and Cost
- •GPUs, TPUs, NPUs
- •Training vs inference
- •Memory + throughput
- •Why compute shapes pricing
Real-world scenario
A team wants to ship AI broadly but has not thought through inference cost, latency budgets, or why the hardware layer affects product feasibility.
Outcomes
- •Explain why AI chips and accelerators matter to product behavior and cost.
- •Describe the difference between training workload and serving workload.
Knowledge checks
- •Why do latency and memory matter so much for inference?
- •What cost tradeoffs appear when traffic grows from demo scale to real usage?
Definition of done
- •Learner can explain compute constraints in product terms, not only hardware jargon.
- •Training and inference are distinguished clearly.
- •The lesson connects cost, latency, and chip constraints to real product decisions.
Build: Create a compute brief that explains how training, inference, memory, and throughput shape one AI feature.
+260 XP
Stage 3
Locked
Tokens, Embeddings, and Transformer Intuition
- •Tokenization
- •Context windows
- •Embeddings
- •Attention + transformer intuition
Real-world scenario
Students keep hearing about tokens, vectors, and transformers but cannot connect those ideas to context limits, retrieval quality, or why long prompts behave differently.
Outcomes
- •Explain the prompt-to-output path with correct token and embedding terminology.
- •Connect context limits and transformer behavior to real product tradeoffs.
Knowledge checks
- •What is the role of tokenization before a model can respond?
- •How does attention change what the model can focus on?
Definition of done
- •Learner can explain token budgets and context windows with concrete examples.
- •Embeddings and attention are connected to retrieval and answer quality.
- •Common misconceptions about “the model understands everything in the window” are corrected.
Build: Build a technical walkthrough that explains token budgets, embeddings, and transformer attention using one product example.
+280 XP
Stage 4
Locked
Major Models and Model Selection
- •GPT, Claude, Gemini
- •Llama, Qwen, Mistral
- •Closed vs open-weight models
- •Latency, safety, and cost fit
Real-world scenario
A team wants to add AI to a real product but keeps choosing models based on hype instead of task fit, latency budget, cost ceiling, privacy constraints, and operational complexity.
Outcomes
- •Choose models based on task requirements instead of hype.
- •Separate reasoning quality, tool use quality, and cost efficiency in evaluation.
Knowledge checks
- •When does an open-weight model make more sense than a hosted API model?
- •Which model characteristics matter most for coding or agent workflows?
Definition of done
- •Model comparison includes quality, latency, safety, cost, and operational fit.
- •Recommendation clearly states why one model is chosen for one workload and not another.
- •Learner can name major model families and their practical tradeoffs.
Build: Compare multiple major LLMs on the same task and document tradeoffs across quality, speed, and cost.
+300 XP
Stage 5
Locked
Prompting, Structured Outputs, and Tool Use
- •Prompt structure
- •Schema-bound outputs
- •Function calling
- •Execution guardrails
Real-world scenario
A support assistant works in demos but fails in production because it invents facts, breaks downstream automation, and has no safe path to call real tools.
Outcomes
- •Design prompts and outputs that product code can validate and trust more easily.
- •Explain why tool execution must stay constrained by application logic.
Knowledge checks
- •Why are schemas safer than free-form answers for product logic?
- •When should a tool call require human confirmation?
Definition of done
- •Output contract is explicit enough for validation and retries.
- •Tool use is guarded by product-side rules rather than only instructions.
- •The system has a fallback path for invalid or ambiguous tool calls.
Build: Build a prompt contract with structured outputs and a validated tool-calling boundary.
+320 XP
Stage 6
Locked
Retrieval, Agents, and Coding Agents
- •RAG pipelines
- •Planning loops
- •Single-agent vs multi-agent
- •Coding-agent workflows
Real-world scenario
A coding assistant can patch small files and a support bot can answer common questions, but both fail on larger tasks because grounding, planning, and tool discipline are weak.
Outcomes
- •Design grounded AI systems that retrieve, reason, and act more reliably.
- •Use agents as structured workflows instead of novelty features.
Knowledge checks
- •What failure mode does retrieval solve better than prompting alone?
- •What tasks are safe for autonomous coding agents and which still need tight human review?
Definition of done
- •Assistant retrieves relevant context instead of answering unsupported questions from memory alone.
- •Agent workflow can inspect, plan, edit, and verify without skipping safety boundaries.
- •The learner can explain when not to use an agent.
Build: Design one grounded AI workflow and one coding-agent workflow with clear boundaries, tool use, and verification steps.
+340 XP
Stage 7
Locked
Evals, Guardrails, Latency, and Cost
- •Quality evals
- •Safety checks
- •Latency budgets
- •Cost budgets
Real-world scenario
An AI feature demos well internally, but leadership needs evidence that it is safe, useful, and cheap enough to ship broadly.
Outcomes
- •Turn AI quality into something measurable rather than anecdotal.
- •Balance user value with cost, latency, and safety constraints.
Knowledge checks
- •What would count as failure for this AI feature?
- •How slow or expensive is too slow or expensive for this product surface?
Definition of done
- •Feature has explicit evaluation criteria beyond anecdotes.
- •Latency and cost budgets are written down and reviewable.
- •Guardrails target real product risks instead of vague concerns.
Build: Create an evaluation sheet and release gate for one AI feature that includes quality, safety, latency, and cost criteria.
+360 XP
Stage 8
Locked
Productivity, CS Impact, and Org Change
- •Workflow redesign
- •Human-in-the-loop design
- •AI productivity measurement
- •How AI changes CS and engineering roles
Real-world scenario
An organization is rapidly adopting AI, but engineers need a clear view of what changes in day-to-day productivity, what stays foundational in CS, and how teams should redesign workflows instead of just adding chatbots everywhere.
Outcomes
- •Explain where AI amplifies software engineering and where fundamentals still dominate.
- •Design AI-assisted workflows with clearer human ownership and measurable productivity goals.
Knowledge checks
- •Which CS fundamentals become more important, not less, in an AI-heavy workflow?
- •What metric would prove a workflow is actually more productive after AI is introduced?
Definition of done
- •Memo clearly explains AI’s impact on systems thinking, abstractions, and engineering roles.
- •Workflow design includes human ownership, evaluation, and fallback behavior.
- •Learner can argue why core CS skills still matter in an AI-assisted workflow.
Build: Redesign one real workflow with AI assistance and write a technical memo on how AI changes engineering practice without replacing core CS skills.
+380 XP
DevOps Route
Automation, infrastructure, observability, and platform reliability.
Stage 1
Locked
CI/CD Automation
- •Pipelines
- •Build/test
- •Artifacts
- •Release gates
Build: Create a CI pipeline with quality gates.
+220 XP
Stage 2
Locked
Infrastructure as Code
- •Terraform basics
- •Environments
- •Secrets
- •State management
Build: Provision infrastructure as code with environments.
+240 XP
Stage 3
Locked
Observability + SRE
- •Metrics, logs, traces
- •Alerting
- •SLOs
- •On-call
Build: Set up dashboards, alerts, and an on-call runbook.
+260 XP
Stage 4
Locked
Platform Engineering
- •Developer portals
- •Golden paths
- •Self-service
- •Policy-as-code
Build: Ship a platform template that others can adopt.
+280 XP
Build Plan: Clear Increments and Rewards
Ship in stages, earn milestones
Each increment is a concrete deliverable. Complete them in order and collect milestone rewards.
Increment 1
Curriculum Core and Progress
- •Finalize core tracks and sequencing
- •Wire completion, XP, and streaks
- •Define clear outcomes for each module
Outcomes
- •Define a learning path that is sequenced instead of random.
- •Ship visible progress state that motivates return visits.
Knowledge checks
- •What makes one module unlock cleanly into the next?
- •How should a learner know they are actually improving?
Build: Deliverable: core curriculum + progress tracking.
+200 XP
Increment 2
Locked
Daily Drills and Resource Packs
- •Daily battle plan drills and timers
- •C/C++ fundamentals resource pack
- •Checkpoints and review prompts
Outcomes
- •Turn passive reading into a daily training loop.
- •Package resources so learners can move faster without hunting for context.
Knowledge checks
- •What makes a daily drill sustainable instead of overwhelming?
- •Which resource packs reduce friction the most for beginners?
Build: Deliverable: 7-day drill pack with links.
+220 XP
Increment 3
Locked
Assessment and Coaching Layer
- •Weekly boss fight assessments
- •Scoring rubrics and feedback loops
- •Promotion criteria for next phase
Outcomes
- •Measure readiness with explicit rubrics instead of vague intuition.
- •Create feedback loops that tell learners what to fix next.
Knowledge checks
- •What makes a checkpoint feel fair and actionable?
- •How should a rubric separate correctness from explanation quality?
Build: Deliverable: assessment flow with rubric.
+240 XP
Increment 4
Locked
Testing and Quality Gates
- •Unit/integration/e2e coverage goals
- •Accessibility and performance budgets
- •CI workflow for consistent quality
Outcomes
- •Protect curriculum changes with quality checks and accessibility baselines.
- •Use CI to keep learning content stable as the platform grows.
Knowledge checks
- •Why do quality gates matter for learning products too?
- •What should fail a release even if the page still renders?
Build: Deliverable: CI green with coverage gates.
+260 XP
Increment 5
Locked
Polish and Launch
- •Copy pass and onboarding clarity
- •Progress share card and milestones
- •Release checklist and analytics hooks
Outcomes
- •Improve onboarding and milestone clarity without changing the UI language.
- •Prepare the curriculum for real learner traffic instead of local demos.
Knowledge checks
- •What does a first-time learner need on day one to keep going?
- •Which analytics hooks prove the content is actually being used?
Build: Deliverable: production-ready launch package.
+300 XP
Increment 6
Locked
Portfolio, Mentorship, and Career Proof
- •Capstone packaging and showcase pages
- •Mentor review loops and feedback templates
- •Interview prep artifacts and portfolio storytelling
Outcomes
- •Convert finished lessons into visible proof of growth.
- •Add mentor-friendly review materials without rebuilding the interface.
Knowledge checks
- •What artifact proves a learner can ship and explain work?
- •How should mentor feedback feed the next study cycle?
Build: Deliverable: portfolio-ready curriculum outputs plus mentor review kit.
+340 XP
Daily Track: Data Structures & Algorithms
30–60 mins/day, every day
Master the patterns that appear in 90% of coding interviews. Practice daily to build muscle memory.
Phase 1: The Foundation (Weeks 1–3)
Build a functional monolithic application with modern best practices.
0/3 weeks complete0%
Week 1
Modern Frontend Engineering
- •React Hooks (useState/useEffect/useContext/useReducer)
- •Component lifecycle & performance optimization
- •State management patterns (Context API, Zustand)
- •Tailwind CSS + responsive design principles
- •Accessibility (ARIA, semantic HTML)
Outcomes
- •Build a responsive, accessible UI with strong state management.
- •Explain core React hooks and performance tradeoffs.
- •Ship a polished dashboard with persistence.
Knowledge checks
- •When should you use useMemo or useCallback?
- •What ARIA roles are required for a custom list UI?
Build: Build a "Task Dashboard" with filtering, sorting, dark mode, and local storage persistence.
+150 XP
Week 2
Locked
RESTful API Design & Backend Fundamentals
- •HTTP verbs, status codes, and headers
- •Resource-oriented URL design
- •Request/Response validation (Zod, Joi)
- •Express.js middleware patterns
- •Error handling & logging best practices
Outcomes
- •Design clean REST APIs with validation.
- •Implement middleware for logging and errors.
- •Return consistent responses with correct status codes.
Knowledge checks
- •What is the difference between 400 and 422?
- •How does Express middleware order affect behavior?
Build: Build an Express server with CRUD endpoints, validation, error handling, and request logging.
+150 XP
Week 3
Locked
Databases & Data Modeling
- •SQL (PostgreSQL) vs NoSQL (MongoDB) - when to use each
- •ACID properties & transaction management
- •Database normalization & denormalization
- •Indexing strategies & query optimization
- •ORMs: Prisma, Drizzle, or Mongoose
Outcomes
- •Model relations and choose the right database.
- •Apply indexing for query performance.
- •Ship migrations with reliable data access.
Knowledge checks
- •When should you denormalize a schema?
- •How do you detect an N+1 query problem?
Build: Persist tasks in PostgreSQL with migrations, relations, and optimized queries. Add full-text search.
+200 XP
Phase 2: Production-Ready Backend (Weeks 4–6)
Harden your application with security, caching, and automated testing.
0/3 weeks complete0%
Week 4
Locked
Authentication & Authorization
- •JWT vs session-based auth (tradeoffs)
- •OAuth2 & OpenID Connect (Google, GitHub login)
- •Password hashing (bcrypt, argon2)
- •RBAC (Role-Based Access Control)
- •OWASP Top 10: XSS, CSRF, SQL Injection, CORS
Outcomes
- •Implement secure auth flows with hashing.
- •Protect routes with roles and permissions.
- •Explain common OWASP risks and mitigations.
Knowledge checks
- •When should you use sessions instead of JWT?
- •How do you prevent CSRF and XSS?
Build: Add Login/Signup with JWT, refresh tokens, protected routes, and role-based permissions.
+200 XP
Week 5
Locked
Caching & Performance Optimization
- •Redis for caching & session storage
- •Cache invalidation strategies (TTL, LRU)
- •CDN basics (Cloudflare, CloudFront)
- •Database query optimization (N+1 problem)
- •Response compression & pagination
Outcomes
- •Design cache strategies with safe invalidation.
- •Measure and explain performance improvements.
- •Avoid common database bottlenecks.
Knowledge checks
- •When do you choose TTL vs manual invalidation?
- •What causes the N+1 problem and how do you fix it?
Build: Implement Redis caching for expensive queries, measure performance improvements with benchmarks.
+250 XP
Week 6
Locked
Testing & CI/CD Pipelines
- •Unit tests (Jest, Vitest)
- •Integration & E2E tests (Playwright, Cypress)
- •Test coverage & quality metrics
- •CI/CD with GitHub Actions
- •Automated deployments & rollback strategies
Outcomes
- •Write a reliable test suite across layers.
- •Automate tests in CI for every change.
- •Plan safe deployments and rollbacks.
Knowledge checks
- •What is the difference between unit and integration tests?
- •What does coverage miss even when it is high?
Build: Write comprehensive tests (80%+ coverage) and set up a CI/CD pipeline that runs tests on every push.
+250 XP
Phase 3: System Design & Scale (Weeks 7–10)
Design and build systems that scale to millions of users.
0/4 weeks complete0%
Week 7
Locked
Architecture Patterns & Scaling Fundamentals
- •Monolith vs Microservices (when to use each)
- •Load balancing (L4 vs L7, NGINX, HAProxy)
- •Horizontal vs vertical scaling strategies
- •Stateless vs stateful services
- •Service mesh basics (Istio, Linkerd)
Outcomes
- •Choose an architecture style for the problem.
- •Explain scaling tradeoffs with confidence.
- •Map services using the C4 model.
Knowledge checks
- •When would you choose a monolith over microservices?
- •What is the difference between L4 and L7 load balancing?
Build: Diagram a scalable architecture using C4 model. Implement a simple load balancer.
+300 XP
Week 8
Locked
Distributed Systems & Advanced Algorithms
- •CAP theorem & consistency models
- •Eventual consistency & conflict resolution
- •Message queues (Kafka, RabbitMQ, SQS)
- •Rate limiting algorithms (Token bucket, Leaky bucket)
- •Bloom filters, Consistent hashing, HyperLogLog
Outcomes
- •Pick consistency models based on requirements.
- •Design async workflows with queues and retries.
- •Apply advanced data structures for scale.
Knowledge checks
- •When is eventual consistency acceptable?
- •How do token bucket and leaky bucket differ?
Build: Refactor "Email Notifications" into a queue-driven microservice with retry logic and dead-letter queues.
+350 XP
Week 9
Locked
System Design Interviews & Real-World Patterns
- •Capacity estimation & back-of-envelope calculations
- •Database selection (SQL vs NoSQL vs NewSQL)
- •Failure modes & fault tolerance
- •Monitoring & observability (Prometheus, Grafana)
- •Tradeoff analysis & storytelling
Outcomes
- •Estimate capacity and justify assumptions.
- •Choose databases and explain tradeoffs.
- •Design observability and failure handling.
Knowledge checks
- •What is a good back-of-envelope throughput estimate?
- •Which metrics define a healthy system?
Build: Practice designing: Twitter feed, URL shortener, Uber ride matching, Netflix video streaming.
+300 XP
Week 10
Locked
Capstone: Production-Grade Full-Stack App
- •Frontend + API + Database + Auth
- •Real-time features (WebSockets, Server-Sent Events)
- •Caching layer & CDN integration
- •Monitoring, logging, and alerting
- •Production deployment with zero-downtime
Outcomes
- •Ship a full-stack capstone with real-time features.
- •Deploy with monitoring and zero-downtime rollout.
- •Demonstrate production-readiness end-to-end.
Knowledge checks
- •When would you use WebSockets vs SSE?
- •How do you deploy with zero downtime?
Build: Build: Real-time collaborative document editor OR live chat with presence indicators.
+500 XP
Phase 4: Operations, Security & Career Proof (Weeks 11–12)
Harden the capstone, prove operational readiness, and package the work for interviews and portfolio review.
0/2 weeks complete0%
Week 11
Locked
Security, Reliability & Incident Response
- •Threat modeling and trust boundaries
- •Secrets handling, audit logs, and access control
- •Backups, restores, and rollback design
- •Runbooks, incident communication, and recovery drills
Outcomes
- •Harden the product with clear security and recovery decisions.
- •Document operational risks and a credible incident response plan.
- •Practice reliability work that goes beyond feature delivery.
Knowledge checks
- •Where is the highest-risk trust boundary in your system?
- •What does a rollback need beyond just old code?
Build: Add threat model notes, secret rotation, audit logging, and an incident drill to the capstone.
+320 XP
Week 12
Locked
Portfolio Packaging, Demos & Interview Readiness
- •Architecture storytelling and design docs
- •Metric-driven demos and project walkthroughs
- •Behavioral narratives anchored to shipped work
- •Portfolio writing, README quality, and reflection
Outcomes
- •Turn the capstone into visible proof of engineering maturity.
- •Explain architecture, tradeoffs, and impact clearly under pressure.
- •Leave the curriculum with an interview-ready artifact set.
Knowledge checks
- •What would a reviewer understand from your README in two minutes?
- •Which tradeoff decision from the capstone best demonstrates judgment?
Build: Publish the capstone with a polished README, architecture brief, demo script, and interview notes.
+360 XP
Start with System Design Games
Tip: pair Weeks 7-12 with System Design so the architecture concepts stick faster.