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 10-week intensive curriculum designed by engineers, for engineers. Build real projects, master system design, and level up your career.
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 10, you’ll have a portfolio of production apps and the confidence to design systems at any scale.
Fundamentals: Top 10 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
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
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
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
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
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
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
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
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
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
Build: Release a small library with README, tests, and versioning.
+150 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 LabBoss 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
Each track is sequential. You must complete the previous stage before moving on to the next.
Why it’s locked: advanced roles depend 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.
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
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
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
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
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
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
Build: Deliverable: production-ready launch package.
+300 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
Start with System Design Games
Tip: Do Week 7 alongside System Design for faster intuition.