Recorded lessonsSelf-pacedCapstone project

Python Full Stack Complete Course

From your first line of code to a deployed web app and a capstone project, for freshers and college students with no coding background

15 modules · 107 video lessons · about 20 hours

I'm interested

About the course

A complete path from zero to full stack in fifteen modules. It starts from everyday life (a program is a recipe, a variable is a labelled box) and assumes no coding background. Then core Python (decisions, loops, lists, dictionaries, functions, files, classes), the tools developers use every day (the terminal, Git and GitHub, virtual environments, pytest), Jupyter notebooks and data handling with pandas and matplotlib, the web (HTML, CSS and JavaScript), SQL databases, REST API design, a backend with FastAPI, a frontend with React, the basics of large language models (prompts, calling an LLM from Python, safe use) and deployment with Docker and GitHub Actions.

You build as you go: a bill splitter, a number guessing game, an expense tracker, a library manager, a data story notebook, a to-do list page, a library database, a notes API and its React front end, an AI summary for your notes, all deployed online. The course ends with a capstone project of your own, planned, built, deployed and scored against a 100-point rubric, and a full mock test.

Who it is for
College students of any branch and freshers looking for a first software job. Nothing about programming is assumed: you have never written code or opened a terminal. You need a laptop or a desktop for the hands-on parts from the third lesson on; a phone is enough to watch.
Format
Recorded video lessons of about ten minutes with slides, worked examples and narration in English, Hindi and Odia. Slides, code and quizzes are in English. Not a live class.
Length
15 modules · 107 video lessons · about 20 hours. One to two hours a day: a lesson of about ten minutes, typing and running its code, and the lesson quiz.
Free lessons
All 8 lessons of module 1. Their notes and quizzes are open now; the videos are being prepared.
Price
₹4,999, paid once. Launch price ₹2,999 for the first 100 students. Enrolment opens soon; no payment is taken now.

What you will be able to do

  • Explain what a program, a variable, a loop, a function, a class, a database, an API and a deployment are, each with an everyday analogy.
  • Write, run and debug Python programs of 50 to 150 lines that use conditions, loops, lists, dictionaries, functions, files, JSON and classes, with tests in pytest, kept in Git and published on GitHub.
  • Explore and clean a CSV dataset in a Jupyter notebook with pandas and present two charts and written findings.
  • Build a web page with HTML, CSS and JavaScript, and a React front end that talks to your own API.
  • Design SQL tables, write SELECT, JOIN and GROUP BY queries, and build a FastAPI backend with validation, a database, login and tests.
  • Explain what a large language model is, write a prompt that returns JSON a program can read, call an LLM from Python with the key kept secret, and check its answer before trusting it.
  • Deploy a full-stack app (API, database and front end) with environment variables, Docker and a GitHub Actions check, and present it in an interview.
  • Finish a capstone project scored against a 100-point rubric, and take the final test.

Curriculum: 15 modules, 111 lessons

107 video lessons, about 20 hours in all. Open a module to see its lessons.

Module 01 Programming from everyday life 8 lessons

No coding background needed. What a program is, told through recipes, vending machines and labelled boxes, then Python set up in the browser or on a laptop, the first programs, values, variables and input, ending with a bill splitter you build yourself.

  1. What a program is: a recipe for a computer Free 9 min

    Explain what a program is with the chai recipe, say why order and exact wording matter to a computer, and spot the missing or out-of-order step in a set of instructions.

  2. How a computer follows instructions Free 9 min

    Describe input, processing, output and memory with a vending machine, and trace three instructions that store and change a value in a labelled box.

  3. Meet Python and run your first line Free 10 min

    Say what a programming language does, open Python in Google Colab with nothing to install (or on a laptop with Python 3.12 and VS Code), and run a first line that prints a greeting.

  4. Printing text and reading error messages Free 10 min

    Print text and numbers, add comments, predict what a short program prints line by line, and read a SyntaxError or NameError to find the line and the fix.

  5. Numbers, text and true or false Free 10 min

    Tell whole numbers, decimals, text and True or False apart, use the seven arithmetic operators, and predict why "2" + "3" is not 5.

  6. Variables: labelled boxes for values Free 10 min

    Store, read and update a value in a variable, trace a program that reassigns one, and choose names Python accepts and a reader understands.

  7. Asking the user: input and conversion Free 10 min

    Read the user's answer with input, turn it into a number with int or float, and format a clear answer with an f-string.

  8. Mini app: a bill splitter Free 11 min

    Build a bill splitter that asks for the bill, the tip percentage and the number of friends, and prints each share rounded to the rupee, testing it with known values.

Module 02 Making decisions and repeating work 9 lessons

Comparisons, if, elif and else, combined conditions, while and for loops, strings step by step and debugging by tracing, ending with a number guessing game.

  1. Comparisons and True or False 10 min

    Compare values with the six comparison operators and chained comparisons (18 <= age < 60), and predict the True or False each gives, including the = versus == mistake.

  2. Decisions with if, elif and else 11 min

    Write a decision with if, elif and else (a grade from marks, a ticket price by age) and trace which branch runs for a given input.

  3. Combining conditions with and, or and not 10 min

    Combine conditions with and, or and not, and predict the result of a rule such as free delivery above 500 rupees or for members.

  4. Repeating with while 11 min

    Repeat work while a condition holds (a savings goal, a PIN with three tries), trace each round, and avoid a loop that never ends.

  5. Repeating with for and range 11 min

    Loop over a range and over text with for, total and count inside a loop, and predict where range stops.

  6. Working with text: indexing, slicing and methods 11 min

    Index and slice a string, use upper, strip, replace and split, and predict the result of a slice with a missing end.

  7. Debugging by tracing 10 min

    Find a bug by tracing a loop in a table and by printing values, and fix an off-by-one error.

  8. Mini app: a number guessing game 12 min

    Build a guessing game with random numbers, a loop, hints and a limited number of tries, and test it by fixing the secret number.

  9. Practice set: decisions and loops Practice set

    Solve ten short problems on conditions, loops and strings (a fee calculator, a times table, counting vowels), each with a test to check your answer and a worked solution to compare.

Module 03 Lists, dictionaries and functions 12 lessons

Lists, tuples, sets and dictionaries; functions with parameters and return values; the standard library; handling errors; reading and writing files and JSON; ending with an expense tracker that saves your data.

  1. Lists: many values in one name 11 min

    Make a list, read items by position (counting from zero), add and remove items, and predict what an index or a negative index returns.

  2. Looping over lists 11 min

    Total, filter and transform a list with a loop and with a list comprehension, and find the largest mark in a class list.

  3. Tuples and sets 10 min

    Choose a tuple for values that should not change and a set to remove duplicates or test membership.

  4. Dictionaries: looking up by name 11 min

    Store and look up values by key (a phone book, a menu with prices), loop over keys and values, and avoid the missing-key error.

  5. Functions: name a job once, use it often 11 min

    Write a function with def, call it with arguments, return a value, and say why print inside a function is not the same as return.

  6. Parameters, defaults and scope 11 min

    Use default and keyword arguments and *args and **kwargs, predict which variable a function sees, and split a long program into small functions.

  7. Python's built-in tools: enumerate, zip, sorted, lambda, map and filter 11 min

    Loop with enumerate and zip, sort with a key, write a short lambda, and choose between map and filter and a list comprehension, predicting each result.

  8. Modules and the standard library 10 min

    Import math, random, datetime and Counter from collections, write your own module with the if __name__ check, and know where to look in the standard library before writing code.

  9. Handling errors with try and except 11 min

    Catch a ValueError from bad input with try and except, re-ask the user, and raise an error of your own with a clear message.

  10. Files and JSON: saving your data 11 min

    Read and write a text file with with open, and save and load a list of dictionaries as JSON.

  11. Practice set: lists, dictionaries and functions Practice set

    Solve twelve problems that combine lists, dictionaries and functions (a marks report, a word counter, a shopping cart), each with tests and a worked solution to compare.

  12. Mini app: an expense tracker 13 min

    Build a command-line expense tracker that adds, lists and totals expenses by category and saves them to a JSON file between runs.

Module 04 Objects, classes and Python's power features 9 lessons

Classes as blueprints, objects with their own data, methods, inheritance and composition, special methods, iterators and generators, decorators and type hints (the two ideas FastAPI is built on), ending with a library manager built from classes and a practice set.

  1. Classes and objects: blueprints and things 11 min

    Explain a class as a blueprint and an object as a thing built from it, write a class with an init method, and make two objects with their own data.

  2. Methods: what an object can do 11 min

    Add methods that read and change an object's data (a bank account's deposit and withdraw), and refuse an invalid change with an error.

  3. Inheritance and composition 11 min

    Reuse a class with inheritance and super, and choose composition (an object holding another) when "has a" fits better than "is a".

  4. Special methods: objects that print, compare and count 10 min

    Give a class __str__, __eq__ and __len__ so its objects print clearly, compare by value and work with len, and predict what print shows before and after.

  5. Iterators and generators: one item at a time 11 min

    Explain what a for loop asks of an object, write a generator with yield that produces values one at a time, and say why it saves memory on a big file.

  6. Decorators: wrapping a function 11 min

    Pass a function to a function, write a decorator that times or logs a call, and read @app.get in FastAPI as the same idea.

  7. Type hints: saying what a function expects 10 min

    Add type hints to variables and functions (int, str, list[str], optional values), check them with an editor, and see why FastAPI and Pydantic read them.

  8. Mini app: a library manager 13 min

    Build a library manager with Book and Member classes, type hints and a generator of overdue books, that lends and returns books and prints who holds what.

  9. Practice set: objects, classes and power features Practice set

    Solve eight problems on classes, special methods, generators and decorators (a bank account, a playlist, a timing decorator), each with tests and a worked solution to compare.

Module 05 Working like a developer 7 lessons

The terminal, Git and GitHub, virtual environments and pip, and automated tests with pytest: the daily tools of every developer, used on the expense tracker.

  1. The terminal and project folders 10 min

    Move between folders, list files, make folders, and run a Python file from the terminal on Windows, macOS or Linux.

  2. Git: saving versions of your work 11 min

    Explain version control with the save-game analogy, and init, add, commit and view the history of a project with Git.

  3. GitHub, branches and pull requests 11 min

    Push a project to GitHub, work on a branch, open a pull request and write a README that shows your work.

  4. Virtual environments and pip 10 min

    Create a virtual environment, install a package with pip, and record and reinstall dependencies from requirements.txt.

  5. Testing your code with pytest 11 min

    Write tests with assert, run them with pytest, read a failing test, and test the function before you change it.

  6. Logging and the debugger 11 min

    Replace print debugging with the logging module, and pause a program at a breakpoint in Visual Studio Code to inspect variables line by line.

  7. Mini app: tests and GitHub for the expense tracker 12 min

    Split the expense tracker into functions with tests, fix a bug the tests find, and publish it on GitHub with a README.

Module 06 Jupyter notebooks 3 lessons

Notebooks as a lab notebook for code: cells, markdown, run order and hidden state, and a clean notebook workflow in Google Colab or JupyterLab.

  1. What a notebook is and when to use one 10 min

    Open a notebook in Google Colab or JupyterLab, run code and markdown cells, and say when a notebook beats a script and when it does not.

  2. Run order and hidden state 10 min

    Predict what a notebook prints when cells run out of order, and use Restart and run all to prove a notebook works top to bottom.

  3. A clean notebook: structure, sharing and moving to scripts 10 min

    Structure a notebook with headings and one job per cell, share it, and move finished code into a .py module.

Module 07 Working with data 7 lessons

CSV files, pandas DataFrames, selecting and filtering, grouping and summaries, cleaning messy data and charts with matplotlib, ending with a data story notebook on a class's marks.

  1. CSV files: tables in plain text 10 min

    Read a CSV file with the csv module and with pandas, and say why a spreadsheet saved as CSV loses formulas and formatting.

  2. pandas DataFrames: a table you can program 11 min

    Load a CSV into a DataFrame, inspect it with head, info and describe, and pick out columns and rows.

  3. Selecting and filtering rows 11 min

    Filter rows with conditions, combine conditions with & and |, sort, and add a computed column.

  4. Grouping and summaries 11 min

    Group rows and compute totals, averages and counts per group, and predict the result of a small group-by.

  5. Cleaning messy data 11 min

    Find and handle missing values, fix types and duplicates, and tidy text columns before counting anything.

  6. Charts with matplotlib 11 min

    Draw a bar, line and histogram chart from a DataFrame, label it properly, and choose the chart that fits the question.

  7. Mini app: a data story notebook 13 min

    Analyse a class's marks in a notebook from raw CSV to cleaned table, summaries and two charts, with the findings written in markdown.

Module 08 How the web works: HTML, CSS and JavaScript 9 lessons

Clients, servers and HTTP through a restaurant analogy; HTML structure and forms; CSS, the box model and flexbox; JavaScript, the DOM, events and fetch; ending with a to-do list page.

  1. How the web works: browsers, servers and HTTP 11 min

    Explain what happens between typing a web address and seeing the page, with the restaurant analogy: browser, server, request, response, URL and status code.

  2. HTML: the structure of a page 11 min

    Write a page with headings, paragraphs, lists, links and images, and nest elements correctly.

  3. HTML forms and inputs 10 min

    Build a sign-up form with labels, text, email, number and select inputs, and say what happens when it is submitted.

  4. CSS: colours, fonts and the box model 11 min

    Style a page with selectors, colours and fonts, and size an element with the box model: content, padding, border and margin.

  5. Layout with flexbox and responsive design 11 min

    Lay out a header and cards with flexbox and make the page work on a phone with a media query.

  6. JavaScript basics for Python learners 11 min

    Write JavaScript variables, functions, arrays and objects, and map each to the Python you already know, including the == versus === trap.

  7. The DOM and events 11 min

    Find elements, change their text and classes, and respond to a click or a form submit.

  8. Fetching data with fetch and JSON 11 min

    Fetch JSON from an API with fetch, await and then, show it on the page, and handle a failed request.

  9. Mini app: a to-do list page 13 min

    Build a to-do list page in HTML, CSS and JavaScript that adds, ticks and deletes tasks and keeps them after a reload.

Module 09 Databases and SQL 9 lessons

Why databases beat spreadsheets for apps; tables, SELECT, filtering, sorting and aggregates; changing data; joins; keys and schema design; indexes and transactions; SQL from Python; ending with a library database.

  1. Why apps need a database 10 min

    Explain tables, rows, columns and keys with a school register, and say why an app keeps its data in a database rather than in files.

  2. SELECT, WHERE and ORDER BY 11 min

    Read data with SELECT, filter it with WHERE, sort it with ORDER BY and limit the rows, predicting the result table.

  3. Counting and totals: aggregates and GROUP BY 11 min

    Count, sum and average with aggregates, group with GROUP BY, filter groups with HAVING, and predict the output.

  4. Changing data: INSERT, UPDATE and DELETE 10 min

    Add, change and remove rows safely, and avoid the UPDATE without WHERE that changes every row.

  5. Joining tables 12 min

    Join two tables on a key with INNER and LEFT JOIN and predict which rows each keeps.

  6. Keys and designing tables 11 min

    Design tables for a small app with primary and foreign keys, one-to-many and many-to-many links, and no repeated data.

  7. Indexes and transactions 11 min

    Say what an index speeds up and what it costs, and group changes in a transaction that all happen or none do.

  8. SQL from Python with sqlite3 11 min

    Connect to SQLite from Python, run queries with placeholders (never string formatting), and read the results into Python.

  9. Mini app: a library database 13 min

    Move the library manager's data into SQLite tables and answer questions with joins: who has which book, and what is overdue.

Module 10 Designing a REST API 3 lessons

HTTP methods and status codes, resources and routes, and pagination and errors: the plan of an API before writing one.

  1. HTTP methods and status codes 10 min

    Pick the right method (GET, POST, PUT, PATCH, DELETE) and the right status code (200, 201, 400, 401, 404, 500) for an action.

  2. Resources and routes 10 min

    Design the routes of a notes app as resources, with request and response JSON for each.

  3. Pagination, errors and safe retries 10 min

    Page through long lists, return errors a client can act on, and say which requests are safe to retry.

Module 11 Building a backend with FastAPI 8 lessons

A first API, path and query parameters, request bodies validated with Pydantic, a database through SQLModel, migrations, users and login, and tests, ending with a notes API.

  1. Your first API with FastAPI 11 min

    Create a FastAPI app, add a GET route, run it with uvicorn and try it in the automatic docs page.

  2. Path parameters, query parameters and bodies 11 min

    Read path and query parameters and a JSON body, and predict the status code FastAPI returns for a bad value.

  3. Validating data with Pydantic 11 min

    Define request and response models with types and limits, and keep secrets such as passwords out of responses.

  4. Connecting a database with SQLModel 12 min

    Store and read notes in SQLite through SQLModel, with a session per request and create, read, update and delete routes.

  5. Changing the schema with migrations 10 min

    Add a column with an Alembic migration instead of deleting the database, and roll it back.

  6. Users, passwords and login 12 min

    Hash passwords, issue a token at login, protect routes so users see only their own notes, and say why a password is never stored as text.

  7. Testing an API 11 min

    Test routes with FastAPI's TestClient and pytest against a throwaway database, including the 401 and 404 cases.

  8. Mini app: the notes API 14 min

    Finish a notes API with sign-up, login, per-user notes, search and tests, ready for a front end.

Module 12 A frontend with React 7 lessons

Components, JSX, props and state, lists and forms, fetching from your own API and organising a small app, ending with a React front end for the notes API.

  1. Why React: building pages from components 10 min

    Explain components with the building-block analogy, create a React app with Vite, and read its folder structure.

  2. JSX and components 11 min

    Write components in JSX, pass data with props, and render a list with keys.

  3. State and events 11 min

    Keep changing data in state with useState, update it on a click, and predict what renders after an update.

  4. Forms in React 11 min

    Build a controlled form, validate it before sending, and show errors next to the field.

  5. Fetching from your own API 12 min

    Load and send data to the notes API with fetch and useEffect, show loading and error states, and fix a CORS error.

  6. Pages and login state 11 min

    Add pages with a router, keep the login token, and send it with every request.

  7. Mini app: the notes app front end 14 min

    Build the notes app's front end: sign up, log in, add, edit, search and delete notes against the notes API.

Module 13 AI basics: large language models 5 lessons

What a large language model is and what it cannot do, tokens and context, prompts that work, calling an LLM from Python with an API key, hallucinations, privacy and safe use, ending with an AI summary feature in the notes app.

  1. What a large language model is 10 min

    Explain a large language model with the phone keyboard's next-word suggestion, say what tokens and the context window are, and tell a task an LLM does well from one it gets wrong.

  2. Writing prompts that work 11 min

    Write a prompt with a role, the task, the context, the output format and an example, and ask for JSON a program can read.

  3. Calling an LLM from Python 12 min

    Call a chat API from Python with the key in an environment variable, read the reply, set the temperature, handle an error, and estimate the cost in tokens.

  4. Hallucinations, privacy and safe use 10 min

    Spot a confident wrong answer and check it, keep passwords and personal data out of prompts, and say what prompt injection is and why output is never run blindly.

  5. Mini app: an AI summary for your notes 13 min

    Add a summary route to the notes API that asks an LLM for a three-line summary in JSON, validates it, and tests it with a fake LLM so the tests need no key.

Module 14 Deployment: putting your app online 7 lessons

From a laptop to the internet: configuration and secrets, Docker, hosting the backend, the database and the frontend, automated checks with GitHub Actions, and logs and a launch checklist.

  1. From your laptop to the internet 10 min

    Explain what deploying means with the home kitchen to restaurant analogy: a server, a domain, HTTPS and a hosted database.

  2. Configuration and secrets 10 min

    Move settings and secrets into environment variables, keep them out of Git, and run the same code in development and production.

  3. Docker basics: one box that runs anywhere 11 min

    Write a Dockerfile for the notes API, build and run the image, and say what a container is with the shipping container analogy.

  4. Deploying the backend and database 12 min

    Deploy the notes API and a hosted PostgreSQL database on a free tier, run the migrations, and check it with the docs page.

  5. Deploying the frontend 10 min

    Build the React app, deploy it to a static host, and point it at the live API with an environment variable.

  6. Automatic checks with GitHub Actions 11 min

    Run the tests on every push with a GitHub Actions workflow and read a failed run.

  7. Logs, monitoring and the launch checklist 10 min

    Read your app's logs, add a health check, and go through a launch checklist before sharing the link.

Module 15 Capstone project 8 lessons

Your own full-stack app from plan to launch: the brief, the plan, three build milestones, the rubric and presenting the project in an interview, then the course's full mock test.

  1. The capstone brief 12 min

    Read the capstone brief: the Placement Prep Tracker (or one of two alternatives), the must-have features, the milestones and the rubric.

  2. Plan your project: stories, schema and routes 12 min

    Turn the brief into user stories, a database schema, the API routes and page sketches before writing code.

  3. Milestone: the backend and database 12 min

    Build and test the capstone API with users, the main resources and the dashboard summary route.

  4. Milestone: the front end and the data notebook 12 min

    Build the React pages for the capstone and a notebook that analyses its exported data.

  5. Milestone: deploy, document and demo 11 min

    Deploy the capstone, write the README with screenshots, and record a two-minute demo.

  6. Rubric and self-review 11 min

    Score your project against the 100-point rubric and fix the gaps before you show it to anyone.

  7. Presenting your project in an interview 10 min

    Explain your project in two minutes, answer five questions you should be ready for, and write the project line and links for your resume.

  8. Python Full Stack final test Final test

    Ten mixed questions in 15 minutes across the course, no negative marking, to see which modules to revise before the full 60-question mocks on the exam page.

Capstone project

You plan, build and deploy a full-stack web app of your own, in three build milestones, and score it against a 100-point rubric. An AI feature is an optional stretch.

Projects (choose one, or propose your own)

  1. Placement Prep Tracker: companies, applications by stage, practice problems by topic, interview dates, a dashboard
  2. College Event Booking: events, seats, bookings, an organiser view
  3. Small Shop Inventory: products, stock, sales, a low-stock report

Every project has

  • Users sign up and log in; each user sees only their own data
  • At least three related tables with keys and one migration after the first
  • A FastAPI backend with create, read, update and delete, validation, correct status codes, pagination and at least ten passing tests
  • A React front end with at least four pages, with loading and error states
  • A dashboard with summaries computed in SQL and a chart
  • A Jupyter notebook that analyses the app's exported data with two charts and written findings
  • Deployed online, secrets in environment variables, an automated test run on every push
  • A README with screenshots, how to run it, the live link and a two-minute demo video

Free practice

Questions

Are these live classes?

No. Every lesson is a recorded video of about ten minutes with slides, worked examples and narration, so you study at your own pace. The lessons are written and checked by our team, and the narration is computer generated. This is different from our internships, which are taught live.

What is free?

The whole first module of each course: its notes and quizzes are open now, and its videos are being prepared. The rest comes with the course.

Can I buy a course today?

Not yet. Enrolment opens soon. Leave your details in the form on the course page and we will write to you when it opens.

What is the launch price?

The lower price shown on each course page, for the first 100 students. After that the list price applies. You pay once; there is no subscription.

Which languages are the lessons in?

The narration is in English, Hindi and Odia. Slides, code and quizzes are in English.

Do I need to install anything?

Not to start. The first lessons run in a browser. The Python Full Stack course needs a laptop or a desktop from its third lesson on, and tells you what to install when you need it.

How is my work checked?

Lessons come with short quizzes. The capstone project is scored by you against a published 100-point rubric, and each course ends with a final test.