The practical AI engineering path for builders who cannot wait four years.
Start with the public 20-lesson syllabus. Upgrade when you want recorded walkthroughs, study packs, WhatsApp Q&A, live batches, project review, mentorship, or institutional delivery.
20 lessons · online · project review · founder-led
What you will build
A portfolio is not a claim. It is a set of artifacts.
ABCsteps is designed around proof a reviewer can inspect: repository, runtime, deployment, AI boundary, and a written explanation of the work.
Repository
GitHub proof of work
Learners should be able to show a repository with meaningful commits, setup notes, and a readable README.
Proof check: Can another engineer clone, read, and understand what changed?
Runtime
Repeatable app execution
The project should run beyond a screenshot: local command, container path, or static build that can be repeated.
Proof check: Is there a clear command or deployment path that starts the app?
AI boundary
AI feature with limits
Model use should be explained as product engineering: prompt shape, JSON payload, fallback path, cost, and human review.
Proof check: Does the AI feature fail safely and explain what the model is allowed to do?
Deployment
A reachable demo surface
A demo should make the difference between localhost, preview, and production clear instead of pretending all URLs are equal.
Proof check: Can someone open the demo and understand what is real versus temporary?
Explanation
Written project narrative
The learner should be able to explain what was built, what broke, what changed, and what should be improved next.
Proof check: Can the learner explain the architecture without hiding behind tool names?
Review
Founder or peer feedback loop
Paid guidance is valuable when it improves the work: a better question, clearer repo, stronger demo, or sharper next step.
Proof check: Did review produce a concrete next action, not just encouragement?
Tool and platform logos are learning-context references only: no affiliation, endorsement, hiring access, salary promise, or placement guarantee.
The transformation arc
Four modules. One continuous shape.
Each module produces a working artefact and a verified milestone. The course is designed so each step makes the next one obvious.
- A
- B
- C
- D
The actual stack
Tools you will use, not just hear about.
These are the technologies the course works with directly. If a tool is on this wall, you will configure it, run it, and ship something with it.
VS Code
Editor
GitHub Copilot
AI Pair
OpenAI
Model API
TypeScript
Type Safety
JavaScript
Web Runtime
Node.js
Runtime
Python
AI Scripts
Nuxt
Static Frontend
Docker
Containers
Git
Version Control
Cloudflare
Edge Network
JSON
Data Format
Operating model
Read publicly. Build seriously. Add guidance when it helps you finish.
The public syllabus proves the teaching quality. Paid plans add recorded walkthroughs, live batches, mentorship, review, and workshops around the same inspectable work.
01·Read
Written lessons are the primary product
Every lesson explains the module clearly enough on the page that you understand the value before opening a terminal — or paying for anything.
02·Build
Each lesson produces an artefact
Code, configuration, terminal output, a repository — something verifiable that did not exist before the lesson.
03·Review
Recall locks understanding
After every lesson there is a short review note you use to write back what was learned, so the lesson sticks in long-term memory.
04·Apply
Articles deepen the model
Pair each lesson with the matching engineering blog article, glossary term, or reading path. The articles teach the deeper why; the lessons teach the doing.
Plans
Start free. Upgrade only when the next layer is useful.
Read enough to judge the teaching, then choose the plan that matches how you actually finish hard work: self-paced, founder-supported, live, private, or institutional.
Inspect first
Start with the syllabus
Use the public lessons and articles first. If the teaching style fits your goal, choose the smallest paid plan that adds the help you need.
Open curriculumFounder guidance
Add guidance when you get stuck
Choose direct guidance when you want study materials, WhatsApp doubt help, and a reviewed project instead of another passive course.
See Job-Ready TrackLive or serious work
Use live review when stakes rise
Live batches, private mentoring, architecture review, and workshops are for learners or teams that need accountability and sharper feedback.
Compare plansPricing
Clear pricing without hiding the learning path.
The public curriculum stays free. Paid plans begin at INR 4,999 and add videos, study packs, WhatsApp Q&A, live cohorts, mentorship, architecture review, or institutional workshops.
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.
Free start
Free written lessons
INR 0
20 lessons, blog, glossary, and reading paths remain readable without signup, checkout, or account creation.
Open lessonsJob-Ready Track
FoundingABCsteps 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 TrackCohort
RecommendedCohort — Live group track
INR 14,999
per cohort batch
A learner who stalls in self-paced courses, needs scheduled live accountability, and can attend Saturday/Sunday IST calls.
Open CohortMentorship
Capacity1:1 Mentorship
INR 49,999
per mentee · 8-week engagement
A career switcher, founder, or engineer with stakes high enough that private review is worth more than another course.
Open MentorshipArchitecture Review
Project Architecture Review
INR 24,999
per session
An engineer, founder, or technical lead with a specific decision expensive enough to justify a serious second opinion.
Open Architecture ReviewWorkshop
Institutional Workshop
INR 2L–5L
quoted after scoping
A college, school, bootcamp, or engineering team with 20-60 participants and a clear AI-engineering capability goal.
Open WorkshopEngineering article system
The public articles make the product easier to trust.
Articles are not filler for traffic. Each one explains a real engineering surface, then points back to a lesson, tool, or proof artifact.
aiClaude Code vs Codex CLI: A Same-Repo Workflow Test
A practical comparison of Claude Code and Codex CLI for real repository work, focused on context handling, patches, tests, review, and supervision cost.
14 min read
devopsPodman vs Docker for Developers in 2026
A developer-first comparison of Podman and Docker focused on local workflow, rootless containers, Compose habits, team fit, and real migration trade-offs.
9 min read
aiClaude Opus 4.7 vs GPT-5.5 — Which AI Coding Agent Should Developers Choose?
A source-backed developer comparison of Claude Opus 4.7 and GPT-5.5, focused on tool surfaces, repo evaluation, supervision cost, and coding-agent trade-offs.
9 min read
Public trust layer
The public site is the proof sample, not the whole business model.
ABCsteps keeps the learning surface readable so a learner can evaluate the method before paying. The commercial layer funds Divyanshu's time: recorded walkthroughs, Q&A, review, mentoring, and institutional delivery.
- 20 written lessons remain publicly readable as the proof sample
- 33 engineering articles explain the deeper models behind the work
- Glossary and reading paths reduce confusion before paid guidance is needed
- A learner can judge the method before choosing a plan
Curriculum
20 written lessons
A complete path from first app to AI-enabled cloud product, with labs and review notes.
Blog
33 deep articles
Explanatory engineering articles on Docker, Git, APIs, AI integration, SEO, and deployment.
Glossary
Plain definitions
Every core term is explained in simple language and connected back to lessons and articles.
Paths
Curated sequences
Ordered reading tracks help learners study containers, APIs, editors, mobile, and version control.
Product system
Lessons, articles, tools, and paid guidance all point to the same proof standard.
The site is organized so learners can move from explanation to practice without getting lost: article for mental model, lesson for hands-on work, glossary for blocked terms, and paid guidance when review matters.
Read
Article first
Use the blog to understand the model behind a topic before opening the hands-on lesson.
Explore
Build
Lesson next
The curriculum turns the idea into a concrete artefact: code, repo, API, deployment, or AI feature.
Explore
Reference
Glossary always
When a term blocks understanding, the glossary gives a short definition and points back to the right page.
Explore
Proof standard
What a learner should be able to show after the path.
Outcome 01
Build a working app
Use AI assistance without losing control of files, code, and verification.
Outcome 02
Publish and explain work
Use GitHub, documentation, and written notes to show what was built and why.
Outcome 03
Deploy with cloud basics
Understand containers, tunnels, APIs, previews, and deployment checks at a practical level.
Outcome 04
Add AI responsibly
Treat AI as an API-backed product feature with costs, errors, and limits.
Begin the path
Start with the free syllabus. Upgrade when you need guidance.
Open the first lesson if you want to judge the syllabus. Compare plans if you already know you need recorded walkthroughs, live accountability, project review, or direct founder guidance.
20 lessons · 33 articles · Glossary · Reading paths