20-lesson learning map

The complete ABCsteps curriculum map. One route from first app to AI product.

Four modules, twenty written lessons, real tools, labs, and proof notes. Read the syllabus first; add videos, Q&A, live batches, or review when you want founder-led support.

Start: Lesson 01; begin with one app
Order: A-D; foundation to product
Work: Read + build; lesson, lab, review
Support: Optional; videos, Q&A, review

Start lesson 01 View module map

Curriculum route

Read one lesson, build one artifact, keep one proof trail.

The page is organized for action. Each module has a capability goal, each lesson has a lab, and each paid plan adds support above the same public route.

01Start at the right module.New learners should begin with Module A. Experienced learners can inspect the later modules first.

02Read the lesson before the lab.Every lesson explains the purpose, tool surface, and expected artifact before asking you to build.

03Keep proof as you move.A repository, demo path, note, screenshot, or review trail makes learning inspectable.

04Add support when needed.Paid plans add Divyanshu-led videos, WhatsApp Q&A, live accountability, or review time.

Public lessons are readable now. Recorded walkthroughs, study packs, Q&A, live review, and private founder time are the paid layer above this route.

Module map

Pick where you are, then continue in order.

Module A is the best start for most learners. Later modules exist so returning learners can jump to cloud, full-stack, or AI-product practice without losing the full route.

A Lessons 01-05

Module A: Engineering Foundations

Lessons 1-5 | Foundation Module

B Lessons 06-10

Module B: Cloud and Deployment

Lessons 6-10 | Deployment Module

C Lessons 11-15

Module C: Full-Stack Systems

Lessons 11-15 | Full-Stack Module

D Lessons 16-20

Module D: AI Product Practice

Lessons 16-20 | AI Product Module

Why these 20 lessons

The course is designed as one finished engineering arc, not a scattered topic index.

Twenty lessons is the smallest complete path that can take a serious beginner from "I can ask AI for code" to "I can explain, run, deploy, document, and review an AI-enabled product." More topics can come later; this spine must stay focused enough to finish.

Purpose in one line

Each module adds one visible capability: workspace control, cloud reach, system assembly, then AI product judgment.

A · Foundations

First prompts become a working project

The first five lessons connect AI assistance, editor control, terminal habits, and GitHub into one manageable workspace.

Proof by lesson 05: a small app in a GitHub repository with a learner-written explanation of what changed.

B · Reach

Local work becomes shareable work

The next five lessons teach containers, tunnels, JSON, APIs, and deployment checks so work can be reviewed outside one laptop.

Proof by lesson 10: a repeatable app path with container, tunnel or deployment notes, and a clear verification checklist.

C · System

Separate pieces become a full-stack product

Lessons eleven to fifteen connect frontend, backend, API routes, storage, and persistence into one inspectable system.

Proof by lesson 15: a working leaderboard-style system where data moves through an API and survives refresh.

D · Judgment

AI usage becomes product practice

The last five lessons add AI as a bounded feature, improve prompting, document the project, polish defects, and choose the next path.

Proof by lesson 20: an AI-enabled product note with prompt, model boundary, error handling, cost awareness, README, and next-step map.

Curriculum proof path

Four modules, one visible engineering trail.

The public syllabus is an execution path. Each module turns into a proof surface: tool fluency, deployable work, system boundaries, and AI product judgment that another engineer can inspect.

Ecosystem boundary

Tool and company logos are operating-context references only. They do not imply affiliation, endorsement, interview access, hiring preference, salary outcome, or placement guarantee.

A · AI pair

Module A: Engineering Foundations

Skill signal: AI-assisted coding

Milestone proof: Publish a small working app and its GitHub repository.

Product engineeringAI tooling teamsFrontend prototyping

B · Containers

Module B: Cloud and Deployment

Skill signal: Container basics

Milestone proof: Containerize and share a working app through a verified deployment path.

Cloud engineeringBackend servicesDevOps teams

C · Model API

Module C: Full-Stack Systems

Skill signal: Model API calls

Milestone proof: Build a small full-stack leaderboard with persistent data.

AI product engineeringBackend platformApplied ML tooling

D · Model API

Module D: AI Product Practice

Skill signal: AI feature design

Milestone proof: Polish the product and add one AI-assisted capability with documentation.

Applied AI productsBackend guardrailsCustomer-facing automation

Lessons 1-5 | Foundation Module

Module A: Engineering Foundations

Start from absolute zero. Learn how code, editors, AI assistance, terminal commands, and GitHub fit together as one working practice.

Ecosystem context

Ecosystem references only: no affiliation, hiring promise, or placement guarantee.

Level: Beginner
Milestone: Publish a small working app and its GitHub repository.

Open module overview

Lesson 0145 min

AI-Assisted Code: Your First App

Use an AI coding assistant to build a small game while learning what the tool is doing, where it helps, and where human judgment still matters.

Lab: Build and inspect a simple browser game.

Tools in lesson

AI-assisted coding starts with verification, not blind trust.

Team surfaces

Product engineeringAI tooling teamsFrontend prototyping

View lesson outline

Lesson 0245 min

Set Up VS Code Like a Developer

Set up a professional editor, understand project files, and use AI assistance to modify an existing app deliberately.

Lab: Set up VS Code and modify a real interface.

Tools in lesson

A professional editor turns AI output into controlled engineering work.

Team surfaces

Product engineeringDeveloper toolsCode review teams

View lesson outline

Lesson 0345 min

Build Your First 3D Scene

Use Three.js concepts to understand scenes, cameras, lighting, and how AI can help scaffold visual experiments.

Lab: Create a small Three.js scene and adjust it safely.

Tools in lesson

3D work teaches the scene-camera-rendering mental model.

Team surfaces

Web graphicsGame-tech prototypesInteractive product UI

View lesson outline

Lesson 0440 min

How Developers Actually Work: The Terminal

The terminal is a precise control surface. Learn the commands developers use to inspect projects and run tools.

Lab: Use shell commands to inspect and run a local project.

Tools in lesson

The terminal is the control surface behind serious engineering work.

Team surfaces

Platform engineeringBackend teamsSupport engineering

View lesson outline

Lesson 0545 min

Your Developer Passport: GitHub

Publish a project on GitHub, understand commits, and begin building a portfolio that shows actual work.

Lab: Create a repository and publish the first project.

Tools in lesson

GitHub makes work visible, reviewable, and easier to trust.

Team surfaces

Engineering hiring loopsOpen-source collaborationFreelance delivery

View lesson outline

Lessons 6-10 | Deployment Module

Module B: Cloud and Deployment

Move beyond local files. Package, configure, and publish software with practical cloud and deployment foundations.

Ecosystem context

Ecosystem references only: no affiliation, hiring promise, or placement guarantee.

Level: Beginner to Intermediate
Milestone: Containerize and share a working app through a verified deployment path.

Open module overview

Lesson 0645 min

Docker: Make Local Software Repeatable

Understand containers by packaging an app into a repeatable environment that behaves consistently across machines.

Lab: Write a Dockerfile and run the app in a container.

Tools in lesson

Containers make software repeatable across machines.

Team surfaces

Cloud engineeringBackend servicesDevOps teams

View lesson outline

Lesson 0745 min

Cloudflare Tunnel: Share a Local App Safely

Learn what a tunnel is, when it is useful, and how Cloudflare can expose a local app for demos without pretending it is full production hosting.

Lab: Share a local app through a Cloudflare Tunnel.

Tools in lesson

A tunnel lets a local app become shareable without pretending it is production.

Team surfaces

Developer relationsInternal toolsPrototype review

View lesson outline

Lesson 0840 min

JSON: The Data Format Apps Share

Every app, API, and configuration file uses structured data. Learn to read and write JSON clearly.

Lab: Model app data as valid JSON and debug common mistakes.

Tools in lesson

JSON is the shared language of APIs, config, and app state.

Team surfaces

API teamsData toolingApp configuration

View lesson outline

Lesson 0945 min

How Apps Talk: APIs Revealed

Call a public API, inspect the response, and connect the idea to how modern applications communicate.

Lab: Call an API and use the returned data in a small interface.

Tools in lesson

APIs are contracts between systems, not magic endpoints.

Team surfaces

Backend engineeringIntegration teamsFull-stack product teams

View lesson outline

Lesson 1045 min

Milestone: Your App Is Online

Review the build, container, and deployment path, then verify the app is reachable outside your local machine.

Lab: Complete the deployment checklist and document the result.

Tools in lesson

Deployment is only real after reachability and behavior are verified.

Team surfaces

Platform teamsProduct engineeringQA and release teams

View lesson outline

Lessons 11-15 | Full-Stack Module

Module C: Full-Stack Systems

Understand how frontends, backends, APIs, databases, and AI providers work together inside useful products.

Ecosystem context

Ecosystem references only: no affiliation, hiring promise, or placement guarantee.

Level: Intermediate
Milestone: Build a small full-stack leaderboard with persistent data.

Open module overview

Lesson 1145 min

AI Products Are API Systems

Deconstruct AI app architecture and make a first model API call while separating product experience from backend mechanics.

Lab: Trace an AI request from interface to provider and back.

Tools in lesson

AI products are ordinary systems wrapped around model APIs.

Team surfaces

AI product engineeringBackend platformApplied ML tooling

View lesson outline

Lesson 1245 min

Frontend and Backend: The Full Picture

Map the browser, server, and database responsibilities before building a leaderboard system.

Lab: Draw and implement the first full-stack boundary.

Tools in lesson

Full-stack thinking separates browser, server, and storage jobs.

Team surfaces

Full-stack teamsProduct engineeringSolution engineering

View lesson outline

Lesson 1345 min

Create Your Own API

Build an Express.js server to receive and return data so the app can do more than display a static screen.

Lab: Build an API route and call it from the frontend.

Tools in lesson

Your own API turns a static interface into a system.

Team surfaces

Backend engineeringAPI platformFull-stack product teams

View lesson outline

Lesson 1440 min

Databases: Store Data Permanently

Use SQLite to understand tables, records, and persistence without adding unnecessary infrastructure.

Lab: Store and retrieve leaderboard records with SQLite.

Tools in lesson

Persistence begins with tables, records, and honest storage boundaries.

Team surfaces

Backend teamsData applicationsProduct analytics

View lesson outline

Lesson 1545 min

Milestone: Online Leaderboard Works

Connect frontend, API, and database, then verify that leaderboard data survives beyond a page refresh.

Lab: Ship a working leaderboard milestone.

Tools in lesson

A real milestone connects frontend, API, and persistent state.

Team surfaces

Full-stack deliveryQA engineeringProduct demos

View lesson outline

Lessons 16-20 | AI Product Module

Module D: AI Product Practice

Add AI features, improve documentation, polish the product, and choose the next engineering direction.

Ecosystem context

Ecosystem references only: no affiliation, hiring promise, or placement guarantee.

Level: Intermediate
Milestone: Polish the product and add one AI-assisted capability with documentation.

Open module overview

Lesson 1645 min

Adding AI to Your App

Use an AI API as a product capability, with clear inputs, outputs, error handling, and cost awareness.

Lab: Connect a model API behind a practical interface.

Tools in lesson

AI belongs behind a clear product boundary with failures and costs handled.

Team surfaces

Applied AI productsBackend guardrailsCustomer-facing automation

View lesson outline

Lesson 1740 min

Prompting for Useful Engineering Output

Learn how to give AI systems enough context, constraints, and verification steps to produce usable engineering help.

Lab: Improve one feature through a verified AI-assisted workflow.

Tools in lesson

Good prompting is context, constraints, examples, and verification.

Team surfaces

AI productivity teamsDeveloper experienceInternal automation

View lesson outline

Lesson 1840 min

What Makes Professional Documentation

Write a README that explains purpose, setup, usage, architecture, and limitations truthfully.

Lab: Write a complete README with setup and limitations.

Tools in lesson

Documentation is part of the product, not decoration after shipping.

Team surfaces

Engineering onboardingDeveloper relationsOpen-source projects

View lesson outline

Lesson 1945 min

Final Polish and Verification

Improve UI, fix defects, and verify that the product behaves as expected before sharing it.

Lab: Run a final defect pass and improve the interface.

Tools in lesson

Polish means evidence-backed fixes, not cosmetic guessing.

Team surfaces

Frontend product teamsQuality engineeringDesign engineering

View lesson outline

Lesson 2045 min

Choosing Your Next Engineering Path

Review the full path and decide whether to go deeper into AI, cloud, frontend, backend, product, or research.

Lab: Prepare a portfolio summary and next-path map.

Tools in lesson

The next path is easier to choose when your tools and proof are visible.

Team surfaces

Early-career engineeringFreelance discoveryFounder-led products

View lesson outline

Course structure

Public syllabus, clear lesson path, and enough context to begin today.

Every lesson is publicly readable on this site — labs, reviews, milestone projects, no signup. Start with the syllabus, then use the reading paths and glossary when a concept needs more depth.

Open lesson 01 Open reading paths

After the public syllabus

The 20 lessons are the spine. Paid guidance is the layer above the spine.

This catalog should help a learner understand the work before paying. When reading alone is not enough, the same offer ladder shows exactly what changes: videos, study pack, live calls, private review, architecture guidance, or institutional delivery.

How to choose

Start with the free lessons. Upgrade when videos, Q&A, live accountability, private review, or institutional delivery helps you finish stronger work.

Compare plans Inspect lessons

Free start

Free written lessons

INR 0

20 lessons, blog, glossary, and reading paths remain readable without signup, checkout, or account creation.

Open lessons

Job-Ready Track

Founding

ABCsteps AI Engineering Course · Job-Ready Track

INR 4,999

A self-motivated learner who has read enough of the public syllabus to trust the teaching style and wants founder guidance without live cohort pressure.

Open Job-Ready Track

Cohort

Recommended