Section 02
Course Description & Rationale
Most development courses start with code. This one starts with a question: why does the internet exist, and why does every line of code you will ever write ultimately serve it?
The internet is the last node — the final destination of every HTTP request, every database query, every deployed application. This course uses that single insight as a unifying thread, weaving together three parallel tracks: the origin stories of the internet and its technologies (Track A), the practical full stack path from HTML to cloud deployment (Track B), and the logical foundations of data structures and algorithms (Track C).
Unlike programs that teach how to write code, this course first teaches why each technology was invented, what problem it solved, and how it works — before a single line is typed. This sequence produces engineers who understand their tools, not just operators who use them.
The goal is not to make the student "job-ready" — a narrow, syntax-focused outcome. The goal is to make the student industry-ready: someone who can reason about problems, make architectural decisions, explain their code to colleagues, and continue learning independently after the course ends.
Section 03
Teaching Philosophy & Design Principles
This course is built on five explicit design principles. These govern every chapter, every homework assignment, and every assessment.
01
Why → What → How
Every concept is introduced with its origin story — the problem it solved, the moment it was invented — before the concept is defined, and before the student touches code.
02
Internet as Last Node
Every chapter connects its topic back to the internet. This thread runs unbroken for all 24 weeks, ensuring the student always knows where they are in the larger system.
03
Restricted Exploration
Each chapter has a clearly defined boundary. The student is shown what lies beyond — but told where to stop for now. Curiosity is encouraged within guardrails, not suppressed.
04
Chapters First, Progress Second
Structure precedes pace. The student advances only after the chapter's learning outcomes are demonstrated — not because the calendar says so.
05
Explain to Advance
Working code that cannot be explained is not learning. At any point the instructor may ask the student to explain any line they have written. If they cannot, the chapter is not complete.
The Chapter Boundary Contract
Every chapter ends with three explicit statements delivered by the instructor:
✓ You have learned: [2–3 concrete things the student can now do or explain]
◼ This is the boundary for now: [What is deliberately not covered yet, and why]
→ If you are curious: [One specific resource, maximum 30 minutes — not more]
This contract prevents the student from going so deep into a subtopic that they lose the main path — and acknowledges their curiosity as legitimate rather than shutting it down.
Section 04
Intended Learning Outcomes
By the end of this course, the student will be able to:
- ILO 1Explain how the internet works — from browser request to server response — covering DNS, HTTP, OSI layers, and the client-server model, without referring to notes.
- ILO 2Build and deploy a complete full stack application: React frontend, Node.js/Express backend, PostgreSQL database, JWT authentication, and cloud hosting on AWS — from scratch, independently.
- ILO 3Reason about algorithmic efficiency — select an appropriate data structure for a problem, estimate time and space complexity, and explain the choice in plain language.
- ILO 4Write version-controlled code using Git and GitHub with meaningful commit messages, branching, and a clean project history from Week 1.
- ILO 5Design and consume a RESTful API — defining endpoints, HTTP methods, request/response formats, and authentication flows.
- ILO 6Articulate the origin story of every technology in the course — why it was invented, what came before it, and what problem it solved.
- ILO 7Deploy a production application to AWS — using EC2, S3, RDS, IAM, and Route53 — and understand the cost and responsibility model of each service.
- ILO 8Identify their own knowledge gaps and continue learning independently using documentation, community resources, and roadmaps after the course ends.
Section 05
Parallel Track Structure
The course runs three simultaneous tracks each week. Tracks are not independent — they are synchronised so that a concept introduced in Track A illuminates what the student builds in Track B or analyses in Track C. The instructor must make these connections explicit every class session.
Track A
Foundation & Internet Origins
The "Why" layer. Every class begins here. Covers how the internet was built, OSI model, protocols, browser rendering, and the origin story of each technology. Runs all 24 weeks.
~20 min per class
Track B
Full Stack Development
The "How" layer. Follows roadmap.sh Full Stack skeleton: HTML → CSS → JS → Node.js → Express → PostgreSQL → React → AWS. All homework projects live here.
~30 min per class
Track C
Data Structures & Algorithms
The "What" layer. Follows roadmap.sh DSA skeleton with a restricted scope — covers what a full stack developer needs. Advanced DS topics are explicitly excluded for this cohort.
~10 min per class
Instructor note — Making the Thread Visible: At the end of every class, explicitly state how the week's Track A concept connects to Track B and Track C. Example: "You learned how DNS resolves a URL (Track A) — that is why your Node server needs a hostname to listen on (Track B) — and the lookup table DNS uses is a Hash Map (Track C)."
Section 06
Week-by-Week Curriculum
Goal: Understand what the internet is, how computers think, and how developers reason — before writing a single line of code.
Week 01
Track A — Foundation
The Internet: Origin Story
ARPANET, Cold War, packet switching, client-server model. Why a global network was needed. Exercise: draw one request's journey from browser to server on paper.
roadmap.sh: Internet Basics
Track B — Full Stack
Git & GitHub
Why version control exists. init, commit, push, pull. Every project in this course lives in Git from today. No exceptions.
roadmap.sh: Git → GitHub
Track C — DSA
What Are Data Structures?
Why organising data matters. A messy desk vs a filing cabinet. No code — only thinking about how computers store and access information.
roadmap.sh: DSA Intro
Week 02
Track A — Foundation
OSI Model
7 layers of communication. Why layered architecture exists. HTTP lives at Layer 7 — Application. Trace a WhatsApp message through all 7 layers.
Track B — Full Stack
Git Branching & Collaboration
Branching, merging, pull requests. GitHub profile setup. README writing. First public repository created and pushed.
roadmap.sh: Git → GitHub
Track C — DSA
Programming Fundamentals
Variables, control structures, functions in plain JavaScript. Pseudo-code first: write logic in English before writing any code.
roadmap.sh: Programming Fundamentals
Week 03
Track A — Foundation
DNS, HTTP & Request-Response
How a URL becomes an IP address. HTTP verbs: GET, POST, PUT, DELETE. Status codes: 200, 404, 500. DevTools Network tab: live anatomy of a real request.
Track B — Full Stack
HTML — Origin & Fundamentals
1991: Tim Berners-Lee, CERN, sharing research documents. Semantic tags, forms, accessibility basics. First webpage — pure structure, no styling.
roadmap.sh: HTML
Track C — DSA
Arrays
Structure, indexing, traversal. Why arrays exist: ordered, contiguous memory. Implement: find an element, reverse an array.
roadmap.sh: Array
Week 04
Track A — Foundation
How Browsers Work
Browser rendering pipeline: HTML → DOM → CSSOM → Render Tree → Paint. Why CSS blocks render. Why JS blocks parsing. What happens in those milliseconds.
Track B — Full Stack
CSS — Fundamentals
Separation of concerns principle. Box model, selectors, specificity, cascade. Personal resume page styled — first project with a clean Git history.
roadmap.sh: CSS
Track C — DSA
Strings as Arrays
String is a character array. Traversal, reversal, search. A URL is a string — the browser parses it character by character.
roadmap.sh: Array
Phase 1 Thread: Week 3 — the student learns DNS/HTTP in Track A while building their first HTML page in Track B. Instructor connects: "This HTML file travels inside an HTTP response. Status 200 means your file was delivered successfully."
Goal: Build visual structure with CSS layouts. Introduce JavaScript and the logical foundations of DSA simultaneously.
Week 05
Track A
How CSS Renders
CSSOM construction. Paint and composite layers. Why render-blocking CSS matters. The real cost of a slow stylesheet on a mobile network.
Track B
CSS Flexbox & Grid
Why float hacks failed — what Flexbox solved. Flexbox: 1D layout. Grid: 2D layout. Build: navigation bar (Flexbox) + page layout (Grid).
roadmap.sh: CSS
Track C
Hash Tables
Key-value pairs, hash functions, collision handling. Why O(1) lookup is powerful. JSON — the internet's data format — is a hash map.
roadmap.sh: Hash Tables
Week 06
Track A
The Mobile Web
2007: iPhone. Why the web had to adapt. Viewport, mobile-first thinking. 60% of internet traffic is now mobile — this changes how we write every line of CSS.
Track B
Responsive Design & Tailwind CSS
Media queries, responsive units. Tailwind CSS: utility-first philosophy. Responsive resume page — works on all screen sizes. Tested on mobile.
roadmap.sh: CSS → Tailwind CSS
Track C
Stacks & Queues
LIFO vs FIFO. Browser back button = Stack. HTTP request queue on a server = Queue. Implement both using JavaScript arrays.
roadmap.sh: Queues, Stacks
Week 07
Track A
JavaScript: The 10-Day Language
1995: Brendan Eich, Netscape, 10 days. Why the browser needed a programming language. What existed before it — static pages, Java applets. The decision that shaped the web.
Track B
JavaScript Basics
Variables, data types, control structures, functions. First interactive page: form validation without a framework. Every line typed — no copy-paste.
roadmap.sh: JavaScript
Track C
Linked Lists
Nodes and pointers. Why linked lists exist: dynamic size, efficient insertion at ends. Implement singly linked list with traversal and insertion.
roadmap.sh: Linked Lists
Week 08
Track A
The JS Engine & Call Stack
V8 engine: how JavaScript executes. Call stack visualised. Event loop introduced — why JavaScript is single-threaded yet handles multiple things.
Track B
DOM Manipulation
DOM tree structure. querySelector, event listeners. Build: interactive To-Do list — add, delete, mark complete. Commit after every working feature.
roadmap.sh: JavaScript
Track C
Algorithmic Complexity
Time vs space complexity. Big-O: O(1), O(log n), O(n), O(n²). Retrospective: apply complexity analysis to all data structures covered so far.
roadmap.sh: Algorithmic Complexity
Phase 2 Thread: Week 8 — JS Engine and Call Stack in Track A directly explains why async behaviour is needed in Track B next week. Instructor previews: "The call stack cannot wait for a network request. Next week, we solve that."
Goal: Master asynchronous JavaScript — the skill that connects the browser to the internet. Checkpoint 1 at the end of this phase.
Week 09
Track A
Async Internet: Why Latency Exists
Speed of light, physical cable distances, server processing time. Why code must not block while waiting. The async problem is, at its root, a physics problem.
Track B
Async JavaScript
Callbacks → callback hell → Promises → async/await. Each evolution shown with the problem it solved. Fetch a real public API. Render data on the page.
roadmap.sh: JavaScript
Track C
Sorting Algorithms
Bubble Sort, Selection Sort, Insertion Sort. Implement each. Compare complexity. Why JavaScript's Array.sort() exists — and when not to trust it.
roadmap.sh: Sorting Algorithms
Week 10
Track A
APIs: The Internet Talks to Itself
How systems communicate over the internet. JSON as the universal language of APIs. REST as an architectural style — not a technology. The API economy.
Track B
Fetch API & Real Data
Consume a real public API. Render results dynamically. Error handling, loading states. First truly interactive web page that talks to the internet.
roadmap.sh: JavaScript → npm
Track C
Searching Algorithms
Linear search O(n) vs Binary Search O(log n). Prerequisite for Binary Search: sorted data. How search engines use these principles at scale.
roadmap.sh: Search Algorithms
Week 11
Track A
npm & the Open Source Ecosystem
How open source packages travel over the internet. npm registry as infrastructure. Semantic versioning. The risk of dependency chains — why node_modules is so large.
Track B
npm — Package Management
Install packages, understand package.json, use a utility library. Enhance the API project with an installed package. Understand what you install.
roadmap.sh: npm
Track C
Recursion & the Call Stack
What recursion is and why it exists. Base case. Stack overflow: what it means literally. Factorial, countdown. DNS resolution is recursive — connect to Track A.
roadmap.sh: Recursion
Checkpoint 01 — End of Month 3
Track B Deliverable: A complete static web application that fetches data from a public API, renders it on a responsive page using async/await, and has a clean Git commit history. The student explains every line — no notes. ·
Track C: Student implements Binary Search from memory and states its time complexity. ·
Track A: Student draws the full request-response cycle of their own application — browser to API server and back.
Goal: Build the server. Own the complete request cycle — from browser to your own database and back.
Week 13
Track A
What Is a Server?
A server is just a computer that listens. Ports, processes, sockets. What happens inside the machine the moment a browser request arrives.
Track B
Node.js — JS Leaves the Browser
2009: Ryan Dahl, V8 outside the browser. Node architecture, non-blocking I/O. First HTTP server: "Hello World" returned as a response. It is live on localhost.
roadmap.sh: Node.js
Track C
Tree Data Structures
Nodes, edges, root, leaf, depth. Why trees exist — hierarchical data. File systems, the HTML DOM, and company org charts are all trees.
roadmap.sh: Tree Data Structures
Week 14
Track A
REST: Roy Fielding's Architecture
2000: Roy Fielding's doctoral dissertation. REST as constraints on HTTP — not a protocol, not a framework. Why REST won over SOAP. What "stateless" really means.
Track B
Express.js — REST APIs
Express: routing, middleware chain, request/response objects. Build a full CRUD REST API for a users resource. Test with a REST client.
roadmap.sh: RESTful APIs
Track C
Binary Search Trees
Insert, search, delete in a BST. In-order traversal yields sorted data. Database indexes are B-Trees — a BST variant. Why database lookups are fast.
roadmap.sh: Binary Search Trees
Week 15
Track A
Databases: Why Files Were Not Enough
ACID properties. Relational model — Codd's 1970 paper. Why a database is not a spreadsheet. SQL vs NoSQL: different tools for different data shapes.
Track B
PostgreSQL — Relational Databases
Tables, columns, data types, primary keys, foreign keys, JOINs. Connect PostgreSQL to the Express API. Data now persists after a server restart.
roadmap.sh: PostgreSQL
Track C
Graph Traversal — BFS & DFS
Breadth First Search, Depth First Search. When to use each. Social networks, web crawlers, route finding — all graph traversal problems.
roadmap.sh: BFS, DFS
Week 16
Track A
Identity on the Internet
HTTPS and TLS. Why HTTP alone is not secure. JWT structure: header, payload, signature. Why passwords are never stored as plain text — hashing explained.
Track B
JWT Authentication
User registration, password hashing with bcrypt, login endpoint, JWT issuance, protected route middleware. The API now knows who is calling it.
roadmap.sh: JWT Auth
Track C
Graph Data Structures
Directed vs undirected. Adjacency list vs adjacency matrix. Shortest path: Dijkstra's Algorithm — concept and motivation, not full implementation.
roadmap.sh: Graph Data Structures
Phase 4 Thread: Week 14 — BST in Track C explains database index speed in Track B. Instructor states: "When PostgreSQL finds a row in milliseconds across a million records, it is using a B-Tree — a BST variant — not a linear scan."
Goal: Build a complete, connected application with a React frontend. Checkpoint 2 — a working, full stack application exists.
Week 17
Track A
Component Thinking — Facebook's Problem
2011: Facebook's UI complexity at scale. The problem with imperative DOM manipulation. Why encapsulated, reusable components were the answer. React's invention.
Track B
React — Components & Props
Functional components, JSX, props, composition. Convert the previous HTML/CSS project into a React application. Understand what the build process does.
roadmap.sh: React → Tailwind CSS
Track C
Dynamic Programming — Intro
Memoisation: storing results of subproblems. Fibonacci with and without memoisation — compare call counts. What overlapping subproblems means.
roadmap.sh: Dynamic Programming
Week 18
Track A
Virtual DOM & Reconciliation
Why re-rendering the real DOM is expensive. React's virtual DOM diff algorithm. Reconciliation: finding the minimum set of changes to make. Why this made React fast.
Track B
React — State, useEffect & APIs
useState, useEffect hooks. Fetch data from the student's own backend API. Display in React components. React Router for navigation between views.
roadmap.sh: React
Track C
Two Pointer & Sliding Window
Two Pointer Technique for array problems. Sliding Window for contiguous subarray problems. Pattern recognition: when does each apply?
roadmap.sh: Two Pointer, Sliding Window
Week 19
Track A
Caching: Speed on the Internet
Why caching exists — latency is not zero. Browser cache, CDN cache, server-side cache. Redis as in-memory cache. Cost of a cache miss vs a database hit.
Track B
Redis — Caching Layer
Redis setup. Cache a slow database query. Invalidation strategy. Measure response time with and without cache. Real performance improvement — not theory.
roadmap.sh: Redis
Track C
Greedy Algorithms & Backtracking
Greedy: when local optimum equals global optimum. Backtracking: explore, decide, undo. Classic problems. Problem-solving pattern recognition drill.
roadmap.sh: Greedy, Backtracking
Checkpoint 02 — End of Month 5
Full Stack Deliverable: A working application — React frontend, Node.js/Express backend, PostgreSQL database, JWT authentication, Redis caching. All layers connected. Running locally with a clean Git history. ·
Student Presentation: The student demonstrates the app and explains every layer — from a user login to data appearing on screen. ·
Track C: Student solves one Medium LeetCode problem and explains the time complexity of their solution.
Goal: Deploy everything to the internet. The student's code becomes a real, publicly accessible application on AWS.
Week 21
Track A
Cloud Computing: Why Servers Moved
Pre-2006: companies owned physical servers. 2006: AWS launched. IaaS vs PaaS vs SaaS with real examples. Shared Responsibility Model — what AWS owns vs what you own.
Track B
AWS — IAM, VPC, EC2
IAM: users, roles, policies — never use root. VPC: private network inside AWS. EC2: launch a server, connect via SSH, deploy the Node.js backend. It is live on the internet.
roadmap.sh: AWS → IAM, VPC, EC2
Track C
DSA Review — Structures & Internet
Review all data structures through the internet lens. Hash maps in DNS. Queues in HTTP servers. Trees in file systems and databases. Graphs in network routing.
Week 22
Track A
CDNs & Global Delivery
How content is served from geographically close edge nodes. S3 + CloudFront: static files cached at the AWS edge nearest the user. Why geography affects load time.
Track B
AWS — S3, CloudFront, Route53, RDS
S3: React frontend as static site. CloudFront: CDN in front of S3. Route53: custom domain. RDS: managed PostgreSQL — migrate local database to cloud.
roadmap.sh: AWS → S3, Route53, RDS
Track C
Algorithms Review — Pattern Recognition
Consolidated review of all problem-solving techniques: Two Pointer, Sliding Window, Recursion, DP, Greedy, BFS/DFS. When to apply each — pattern drill.
roadmap.sh: Problem Solving Techniques
Week 23
Track A
CI/CD: How Code Travels to Production
Continuous Integration, Continuous Deployment. The pipeline from laptop to server. GitHub Actions as automation infrastructure. Why automated deployment reduces human error.
Track B
GitHub Actions — CI/CD Pipeline
Write a workflow: on push to main → build → deploy to EC2 and S3 automatically. The application now deploys itself on every commit.
roadmap.sh: GitHub Actions
Track C
Merge Sort & Divide and Conquer
Merge Sort: O(n log n). Divide and Conquer as a general strategy. Implement Merge Sort. Compare with previously learned sorts. When does the choice matter?
roadmap.sh: Merge Sort, Divide & Conquer
Checkpoint 03 — Capstone & Course Completion
Capstone Deliverable: A production-deployed full stack application on AWS — React on S3+CloudFront, Node.js on EC2, PostgreSQL on RDS, JWT auth, Redis cache, custom domain via Route53, CI/CD via GitHub Actions. Written README and architecture diagram. ·
Final Presentation: Student presents the application and explains every architectural decision. Traces a user's request from browser click to database query to response — in full, without notes. ·
Track C Final: Student identifies one data structure used inside their application, explains it, and justifies why it was the right choice.
Phase 6 Thread — Full Circle: Week 24. The student's code is live on the internet. DNS resolution, HTTP requests, OSI layers, browser rendering, data structures, algorithms, authentication, caching, databases — all operating inside their deployed application right now. The instructor makes this explicit.
Section 07
Assessment & Evaluation
Assessment in this course is mastery-based, not time-based. A student does not advance past a checkpoint by completing a week — they advance by demonstrating the outcomes. There are no letter grades. There is completion and incompletion, with specific, actionable feedback for the latter.
One defined task per week. Submitted as a GitHub repository. Evaluated on: Does it work? Can the student explain every line? Is the chapter boundary respected?
End of Month 3. Live demo of API-connected web app. Student draws the request-response cycle of their own app from memory.
End of Month 5. Live full stack application demo. Student presents and explains every layer. One LeetCode Medium solved and explained.