Popular starting points

Career AcceleratorAdvanced

Python Full Stack + GenAI

Python, a backend framework, frontend development, SQL, APIs, testing, deployment and GenAI integration.

Talk to a counsellor about Python Full Stack + GenAI

Fees, batch dates and timings are shared by a counsellor. No payment is needed to ask.

What you will cover
  • Python
  • a backend framework
  • frontend development
  • SQL
  • APIs
  • testing
  • deployment
  • GenAI integration

Topic list from the institute's programme record.

Certification

Certificate terms for this programme are confirmed by the institute at admission. Any ADIVAS course-completion certificate is an institute certificate; it is not a university degree, an externally accredited qualification or a vendor certification (such as AWS or Microsoft) unless the institute states so in writing.

Curriculum 0.1 · Draft: written for ADIVAS and awaiting academic review and approval. Topics and weeks may change before your batch starts.

Your skill trail

You move through 8 stations. Each week builds one skill you can show, not just a topic you have heard.

  1. Python foundations

    Write, test and debug Python programs with functions, data structures, files and classes.

    • Week 1 Python setup, variables and control flow
    • Week 2 Functions and data structures
    • Week 3 Files, exceptions, modules and environments
    • Week 4 Object-oriented Python
    • Week 5 Git, pytest and debugging
    • Week 6 Working with web data and scripts

  2. Databases and SQL

    Design a relational database and query it with SQL and transactions.

    • Week 7 Relational databases and SQL basics
    • Week 8 Joins, design and transactions

  3. Django web development

    Build a database-driven Django application with forms, authentication and an admin.

    • Week 9 Django project, URLs and views
    • Week 10 Templates, static files and forms
    • Week 11 Models, ORM, migrations and admin
    • Week 12 Relationships, authentication and query performance

  4. REST APIs and back-end testing

    Expose secure, documented REST APIs and test them thoroughly.

    • Week 13 REST APIs with Django REST Framework
    • Week 14 API authentication, permissions and error handling
    • Week 15 Testing and documenting the API

  5. Front-end development

    Build responsive interfaces with JavaScript and React and connect them to the API.

    • Week 16 HTML, CSS and responsive layout
    • Week 17 JavaScript, DOM and fetch
    • Week 18 React components, hooks and routing
    • Week 19 Connecting React to the secured API

  6. Generative AI and responsible use

    Understand LLMs, use AI assistants with review and integrate an LLM feature safely.

    • Week 20 Generative AI foundations and AI-assisted development
    • Week 21 Integrating an LLM into the application

  7. Delivery

    Containerise, automate checks and deploy with safe configuration.

    • Week 22 Docker, CI and deployment

  8. Capstone

    Plan, build, harden and present a complete application with a GenAI feature.

    • Week 23 Capstone build sprint
    • Week 24 Capstone hardening and presentation

  9. Learning Centre Portal with an AI Course Helper (capstone)

    Your project, reviewed by a trainer.

The ADIVAS mastery ladder: how each skill is recognised
  1. Explored You have seen the idea and tried a first example.
  2. Practising You can do it with hints and keep improving.
  3. Proficient You complete the weekly practical task correctly on your own.
  4. Proven You apply it in a project reviewed by your trainer.

Skill-level tracking is being added to the learner workspace. Your trainer already reviews weekly practical work.

What you will be able to do

  • Write clear Python programs using functions, data structures, files, classes and modules.
  • Use virtual environments, Git and pytest to build, test and debug code in a daily workflow.
  • Design a relational schema and write SQL for CRUD, joins, aggregates and transactions.
  • Build Django applications with models, views, templates, forms, authentication and the admin.
  • Build documented, validated and permission-protected REST APIs with Django REST Framework.
  • Build a responsive front end with HTML, CSS, JavaScript and React that consumes the API.
  • Test the back end with pytest and API test cases, and the front end with manual and component checks.
  • Explain how large language models work at a practical level, including tokens, context, hallucination and evaluation.
  • Integrate an LLM API into a Django service with safe prompts, validated output, cost and privacy controls and a simple retrieval feature.
  • Containerise with Docker, automate checks with CI and deploy with configuration and secrets kept outside the code.
  • Draw and explain client-server, API-flow and AI-integration architecture diagrams.
  • Use AI coding assistants responsibly and deliver a documented capstone application.

Who it suits

  • School Class 11–12 students who have tried Python or block coding and want to see how real web apps and AI features are built, learning concepts and a small working version.
  • College Engineering, science and computer-application students who want a structured, project-based path to Python web development and applied AI.
  • Professional Working professionals and career changers who want to build and deploy Python web applications and add GenAI features sensibly.

Prerequisites: Basic computer skills and school-level mathematics. No earlier programming is required; Python is taught from the start, at a faster pace than a beginner-only course. Tools: Python 3 (current stable release) with venv and pip, VS Code or PyCharm Community, Django and Django REST Framework, PostgreSQL and a SQL client (SQLite for early practice), pytest and pytest-django, Node.js, npm and React with Vite, Git and GitHub, Docker and GitHub Actions, Postman or a similar API client, An LLM API from a provider with a free or low-cost tier, with keys kept in environment variables, An AI coding assistant used with review.

Weekly plan

Python foundations Weeks 1–6

Week 1: Python setup, variables and control flow

Theory
  • Installing Python, running scripts and the REPL
  • Variables, types, input and f-strings
  • if/elif/else, for and while loops
Lab
Set up Python and an editor; write a fee calculator with GST, a grade classifier and a multiplication-table program.
Homework
Solve ten small logic problems such as prime check, digit sum and a number-guessing game.
Deliverable
A folder of ten solved programs ready for Git.
Weekly checkpoint
Predict the output of five snippets and fix an indentation and a type error.
You will be able to
Write clear Python programs using functions, data structures, files, classes and modules.

Week 2: Functions and data structures

Theory
  • Functions, parameters, defaults and return values
  • Lists, tuples, sets and dictionaries
  • Comprehensions and sorting
  • Choosing the right structure
Lab
Build a marks manager that stores students in a dictionary, ranks them and exports a sorted list using functions.
Homework
Count word frequency in a paragraph with a dictionary and with a comprehension.
Deliverable
marks_manager.py with at least five functions.
Weekly checkpoint
Code reading: trace a dictionary update and fix a mutable default argument bug.
You will be able to
Write clear Python programs using functions, data structures, files, classes and modules.

Week 3: Files, exceptions, modules and environments

Theory
  • Reading and writing text, JSON and CSV files
  • try/except and raising errors
  • Modules, packages and imports
  • Virtual environments and pip
Lab
Read a CSV of shop sales, summarise it by item into a new CSV and handle a missing file and a bad number.
Homework
Create a virtual environment, install requests and list the packages in requirements.txt.
Deliverable
sales_report project with a requirements.txt and a README.
Weekly checkpoint
Debug a script that crashes on an empty CSV row.
You will be able to
Write clear Python programs using functions, data structures, files, classes and modules. Use virtual environments, Git and pytest to build, test and debug code in a daily workflow.

Week 4: Object-oriented Python

Theory
  • Classes, objects, __init__ and methods
  • Encapsulation, properties and __str__
  • Inheritance and composition
  • Dataclasses and when to use them
Lab
Model a BankAccount and SavingsAccount with deposit, withdraw and interest; raise a custom exception for an overdraw.
Homework
Model a Course and Student relationship and print an enrolment report.
Deliverable
A bank-account module with documented behaviour.
Weekly checkpoint
Predict the output of an inheritance example and explain super().
You will be able to
Write clear Python programs using functions, data structures, files, classes and modules.

Week 5: Git, pytest and debugging

Theory
  • Git workflow: commit, branch, merge and pull request
  • pytest: assertions, fixtures and parametrised tests
  • Test-case design: happy path, boundary and failure
  • Debugging with tracebacks, print and the debugger
Lab
Push the bank-account code to GitHub, write ten pytest tests including boundary cases and fix two bugs the tests reveal.
Homework
Resolve a prepared merge conflict and write a parametrised test.
Deliverable
A GitHub repository with a passing test suite and clear commit history.
Weekly checkpoint
Write test cases for a described function and read a pytest failure report.
You will be able to
Use virtual environments, Git and pytest to build, test and debug code in a daily workflow.

Week 6: Working with web data and scripts

Theory
  • HTTP basics and the requests library
  • Parsing JSON from an API and handling status codes and timeouts
  • Writing a command-line tool with argparse
  • Logging instead of print
Lab
Write a script that fetches data from a public API, handles failures with retries and saves a summary to a file.
Homework
Add logging and a --city style option to the script.
Deliverable
A documented command-line API client.
Weekly checkpoint
Read a requests call and spot the missing timeout and error handling; draw the client-server flow.
You will be able to
Write clear Python programs using functions, data structures, files, classes and modules. Draw and explain client-server, API-flow and AI-integration architecture diagrams.
Databases and SQL Weeks 7–8

Week 7: Relational databases and SQL basics

Theory
  • Tables, keys and data types
  • CREATE, INSERT, SELECT, UPDATE, DELETE
  • WHERE, ORDER BY, LIMIT and constraints
Lab
Install PostgreSQL, create a training-centre schema for students, courses and fees and write ten queries.
Homework
Write queries for unpaid fees, courses above a price and the five newest students.
Deliverable
schema.sql and queries.sql scripts that run from scratch.
Weekly checkpoint
Write five queries from descriptions and spot an UPDATE without a WHERE.
You will be able to
Design a relational schema and write SQL for CRUD, joins, aggregates and transactions.

Week 8: Joins, design and transactions

Theory
  • Foreign keys, one-to-many and many-to-many
  • INNER and LEFT JOIN, GROUP BY and HAVING
  • Normalisation and entity-relationship diagrams
  • Indexes, EXPLAIN and transactions with ACID
  • Using SQL from Python with parameters (and why string-building is unsafe)
Lab
Add enrolments and payments, write joins for fee totals per course, add an index, and run a transfer-style transaction from Python that rolls back on failure.
Homework
Draw the ER diagram and show an SQL injection attempt blocked by parameters.
Deliverable
ER diagram, SQL file and a Python script demonstrating a rollback.
Weekly checkpoint
Choose the right join for three cases and find an injection risk in a given snippet.
You will be able to
Design a relational schema and write SQL for CRUD, joins, aggregates and transactions. Draw and explain client-server, API-flow and AI-integration architecture diagrams.
Django web development Weeks 9–12

Week 9: Django project, URLs and views

Theory
  • How Django handles a request: URLconf, view, response
  • Projects and apps, settings and the development server
  • Function and class-based views in outline
  • Environment-based settings and SECRET_KEY safety
Lab
Create a Django project with a courses app and views that return a course list and a detail page from in-memory data.
Homework
Draw the request flow through Django for a course detail page.
Deliverable
A running Django project with two pages and a request-flow diagram.
Weekly checkpoint
Fix a URL pattern that does not match and place the files of a request on a diagram.
You will be able to
Build Django applications with models, views, templates, forms, authentication and the admin. Draw and explain client-server, API-flow and AI-integration architecture diagrams.

Week 10: Templates, static files and forms

Theory
  • Template language, inheritance and static files
  • Django forms and validation
  • CSRF protection and why it matters
  • Messages and redirects after POST
Lab
Build a base template and add an enquiry form with server-side validation that shows errors and a success message.
Homework
Add a custom validator that rejects a phone number that is not 10 digits.
Deliverable
Templated pages with a validated, CSRF-protected form.
Weekly checkpoint
Identify a missing CSRF token and a form that fails to show errors.
You will be able to
Build Django applications with models, views, templates, forms, authentication and the admin.

Week 11: Models, ORM, migrations and admin

Theory
  • Models, fields and migrations
  • ORM queries: filter, exclude, order_by, annotate and aggregate
  • Django admin customisation
  • Seed data with fixtures or a management command
Lab
Replace in-memory data with models for Course and Student; run migrations, customise the admin and write ORM queries for reports.
Homework
Print the SQL behind two ORM queries and compare it with hand-written SQL.
Deliverable
Database-backed course catalogue with an admin.
Weekly checkpoint
Write ORM code for a described query and fix a migration error.
You will be able to
Build Django applications with models, views, templates, forms, authentication and the admin. Design a relational schema and write SQL for CRUD, joins, aggregates and transactions.

Week 12: Relationships, authentication and query performance

Theory
  • ForeignKey, ManyToMany and related names
  • Users, sessions, login, logout and permissions
  • select_related and prefetch_related; the N+1 problem
  • Pagination
Lab
Add enrolments, login-protected pages for students and a staff-only fee report; remove an N+1 problem found with query counting.
Homework
Write a short note on which pages need which permission and why.
Deliverable
A multi-user Django app with enrolment and role-based pages.
Weekly checkpoint
Spot the N+1 problem in a template loop and fix a missing login_required.
You will be able to
Build Django applications with models, views, templates, forms, authentication and the admin.
REST APIs and back-end testing Weeks 13–15

Week 13: REST APIs with Django REST Framework

Theory
  • REST resources, methods and status codes
  • Serializers, validation and viewsets
  • Routers and API versioning basics
  • Request and response structure for a clean API
Lab
Expose courses and enrolments as REST endpoints with validation and test them in Postman.
Homework
Write an endpoint table with methods, statuses and example JSON.
Deliverable
A working DRF API with a Postman collection.
Weekly checkpoint
Choose status codes for six situations and complete a partial serializer.
You will be able to
Build documented, validated and permission-protected REST APIs with Django REST Framework. Draw and explain client-server, API-flow and AI-integration architecture diagrams.

Week 14: API authentication, permissions and error handling

Theory
  • Token or JWT authentication and password hashing
  • Permissions: authenticated, staff and object-level
  • Consistent error responses and throttling
  • CORS and common API risks
Lab
Add token login, restrict endpoints by role, return a uniform error shape and add throttling to login.
Homework
Write a threat checklist for the API and the control for each item.
Deliverable
Secured API with a table of public, authenticated and admin endpoints.
Weekly checkpoint
Find the broken access control in a sample view.
You will be able to
Build documented, validated and permission-protected REST APIs with Django REST Framework.

Week 15: Testing and documenting the API

Theory
  • pytest-django: fixtures, test database and API client
  • Testing permissions and validation failures
  • Mocking external services
  • OpenAPI documentation for the API
Lab
Write fifteen tests for the course and enrolment endpoints, including unauthorised access, and publish OpenAPI documentation.
Homework
Introduce a bug on purpose, see a test fail and fix it.
Deliverable
A passing test suite and generated API documentation.
Weekly checkpoint
Complete a partial API test and explain why a test is flaky.
You will be able to
Test the back end with pytest and API test cases, and the front end with manual and component checks. Build documented, validated and permission-protected REST APIs with Django REST Framework.
Front-end development Weeks 16–19

Week 16: HTML, CSS and responsive layout

Theory
  • Semantic HTML and accessible forms
  • Flexbox, grid and the box model
  • Media queries and mobile-first design
Lab
Build a responsive course catalogue page from a design sketch and check it on a phone-width viewport.
Homework
Run a keyboard-only and zoom check and fix three issues.
Deliverable
A responsive static page ready for data.
Weekly checkpoint
Fix a layout bug and read a CSS rule with a specificity conflict.
You will be able to
Build a responsive front end with HTML, CSS, JavaScript and React that consumes the API.

Week 17: JavaScript, DOM and fetch

Theory
  • Modern JavaScript: let/const, arrow functions, arrays and objects
  • DOM events and manipulation
  • Promises, async/await and fetch
  • Handling loading and error states
Lab
Fetch courses from the DRF API, render cards, add a client-side filter and show loading and error states.
Homework
Rewrite a promise chain with async/await and add a retry button.
Deliverable
A JavaScript catalogue page calling the live API.
Weekly checkpoint
Predict the output order of a mixed async snippet and fix a missing await.
You will be able to
Build a responsive front end with HTML, CSS, JavaScript and React that consumes the API.

Week 18: React components, hooks and routing

Theory
  • Vite, JSX, components and props
  • useState, useEffect and lists with keys
  • Controlled forms and React Router
  • Custom hooks for data fetching
Lab
Rebuild the catalogue in React with list, detail and add-course pages and a useFetch hook.
Homework
Fix a stale-state bug and an effect missing a dependency.
Deliverable
A multi-page React app reading from the API.
Weekly checkpoint
Debug an infinite effect loop and fix a missing key warning.
You will be able to
Build a responsive front end with HTML, CSS, JavaScript and React that consumes the API.

Week 19: Connecting React to the secured API

Theory
  • Sending tokens and handling 401 responses
  • Token storage trade-offs
  • CORS configuration between React and Django
  • Environment-based API URLs and front-end component tests
Lab
Add login, protected routes and role-based screens, handle expired tokens and write six component tests.
Homework
Write a one-page note choosing a token storage approach and its risks.
Deliverable
A working full-stack application running locally.
Weekly checkpoint
Trace a login request on a diagram and find the cause of a CORS error.
You will be able to
Build a responsive front end with HTML, CSS, JavaScript and React that consumes the API. Build documented, validated and permission-protected REST APIs with Django REST Framework. Test the back end with pytest and API test cases, and the front end with manual and component checks. Draw and explain client-server, API-flow and AI-integration architecture diagrams.
Generative AI and responsible use Weeks 20–21

Week 20: Generative AI foundations and AI-assisted development

Theory
  • What LLMs do: tokens, context windows, prompts and why they can be wrong
  • Hallucination, bias and limits; honest evaluation of tool relevance
  • AI-assisted coding: where it helps, where it fails, how to review
  • Privacy, licensing, academic honesty and recording AI use
Lab
Ask an assistant to write a Django view and tests; review for correctness, security and style, fix the problems and write a review note; compare three prompts for the same task.
Homework
Keep a log of three tasks, how long each took with and without AI and whether the output was right.
Deliverable
An AI-use log and a review note attached to a pull request.
Weekly checkpoint
Review a prepared AI-generated view and list its defects, including an injection risk.
You will be able to
Explain how large language models work at a practical level, including tokens, context, hallucination and evaluation. Use AI coding assistants responsibly and deliver a documented capstone application.

Week 21: Integrating an LLM into the application

Theory
  • Calling an LLM API from the server, never from the browser
  • Prompt design, system instructions and structured JSON output with validation
  • Retrieval basics: embeddings, similarity search and grounding answers in your own documents
  • Cost, latency, rate limits, caching, logging and removing personal data from prompts
  • Evaluating a feature: a test set of questions, checking accuracy and failure cases
Lab
Add a 'Ask about courses' feature to the Django app: retrieve matching course descriptions, send them with the question to the LLM API, validate the structured answer and show source references; build a 15-question evaluation set.
Homework
Write a short report of the evaluation results, the failures and the fallback behaviour you added.
Deliverable
A working AI-assisted question feature with an evaluation table and a data-handling note.
Weekly checkpoint
Identify the privacy and prompt-injection risks in a given design and propose controls.
You will be able to
Integrate an LLM API into a Django service with safe prompts, validated output, cost and privacy controls and a simple retrieval feature. Draw and explain client-server, API-flow and AI-integration architecture diagrams. Use AI coding assistants responsibly and deliver a documented capstone application.
Delivery Weeks 22

Week 22: Docker, CI and deployment

Theory
  • Dockerfiles and Docker Compose for Django, the front end and PostgreSQL
  • GitHub Actions: install, test and lint on every push
  • Environment variables, secrets and DEBUG off in production
  • Deploying to a cloud platform or VM; health checks, logging and rollback thinking
Lab
Containerise the stack, add a CI workflow running tests, deploy with secrets set in the platform and verify a health endpoint and logs.
Homework
Write a one-page runbook: deploy, roll back and check health.
Deliverable
Green CI run, a live URL and a runbook.
Weekly checkpoint
Read a Dockerfile and a Django settings file and find a secret or debug setting that must change.
You will be able to
Containerise with Docker, automate checks with CI and deploy with configuration and secrets kept outside the code. Draw and explain client-server, API-flow and AI-integration architecture diagrams.
Capstone Weeks 23–24

Week 23: Capstone build sprint

Theory
  • User stories, minimum viable scope and a task board
  • Feature branches and pull-request reviews
  • Definition of done: tests, documentation, deployment and AI-use notes
Lab
Build the capstone features in two sprints with daily stand-ups; each feature gets a pull request, tests and a review.
Homework
Update the board and write acceptance criteria for the remaining work.
Deliverable
Working capstone core merged to main with tests.
Weekly checkpoint
Mid-point demo of the working core with test results.
You will be able to
Use AI coding assistants responsibly and deliver a documented capstone application. Test the back end with pytest and API test cases, and the front end with manual and component checks.

Week 24: Capstone hardening and presentation

Theory
  • Security, performance and AI-risk review checklist
  • README, API documentation and architecture diagram
  • Demo skills and reflection
Lab
Fix review findings, deploy the final version and rehearse a ten-minute demo with an architecture diagram and a live walkthrough including the GenAI feature.
Homework
Write a reflection on what you would improve and where AI helped or misled.
Deliverable
Deployed capstone, repository, documentation and demo.
Weekly checkpoint
Final demo and viva before a review panel.
You will be able to
Use AI coding assistants responsibly and deliver a documented capstone application. Containerise with Docker, automate checks with CI and deploy with configuration and secrets kept outside the code. Draw and explain client-server, API-flow and AI-integration architecture diagrams. Integrate an LLM API into a Django service with safe prompts, validated output, cost and privacy controls and a simple retrieval feature.

Sample lessons

Week 9

How Django handles a request

When a browser asks for a page, Django receives an HTTP request and follows a fixed path. The URL configuration matches the path to a view function. The view may read or write data through models, which talk to the database, and then returns a response: a rendered HTML template or JSON. Knowing this path tells you where to look when something breaks: a 404 usually means the URL did not match, an error page often points to the view, and wrong data points to the model or query. Middleware also runs on the way in and out, handling sessions, security and CSRF.

  1. 1Browser requests /courses/3/
  2. 2Django URL configuration matches the path
  3. 3View runs
  4. 4Model queries the database
  5. 5Template renders the page
  6. 6Response returns to the browser
A 404 points to the URL step, wrong data to the model step.

Step by step

  1. Add a path('courses/<int:pk>/', views.course_detail) entry in urls.py.
  2. Write the view that receives the request and the pk.
  3. Fetch the course with the model and raise a 404 if it does not exist.
  4. Render a template with the course in the context.
  5. Open the URL in the browser and read the terminal log line for the status code.

In real life

On a training-centre site, a student opens the page of one course. Django matches the URL, loads that course from the database and sends back the filled-in page.

Worked example

Problem. Opening /courses/99/ shows an unhandled DoesNotExist error page. How should the view be fixed?

Solution. Use get_object_or_404(Course, pk=pk) instead of Course.objects.get(pk=pk). It raises Http404 when the row does not exist, so Django returns a proper 404 response instead of a server error.

Common mistakes

  • Putting database logic inside templates instead of views or models.
  • Running with DEBUG on in production and exposing detailed error pages.
  • Forgetting to add the new app to INSTALLED_APPS.

Try it yourself

  • Draw the path from URL to response for the course list page.
  • Explain what the user sees for a missing course and why it should be a 404 and not a 500.

Week 21

Adding an LLM feature safely: retrieve, ask, validate

A language model predicts likely text. It does not look facts up, so it can give fluent but wrong answers. For a feature that must answer from your own data, first retrieve the relevant text, such as the best-matching course descriptions, and send it with the question, telling the model to answer only from that text and to say when it cannot. Call the model from your server, never from the browser, so the API key stays secret. Ask for structured output such as JSON and validate it before use. Remove personal data from prompts, set limits for cost and rate, log failures and measure quality with a fixed set of test questions rather than a few lucky examples. If the model is unsure or the output is invalid, show a safe fallback message.

  1. 1React sends the question to Django
  2. 2Retrieve matching passages from the database
  3. 3Build prompt and call the LLM API with a secret key
  4. 4Validate the JSON answer and sources
  5. 5Return the answer or a safe fallback
The key and the checks live on the server.

Step by step

  1. Collect the documents and split them into small passages.
  2. For a question, find the most relevant passages with keyword or embedding similarity.
  3. Build a prompt with instructions, the passages and the question; call the LLM from Django using a key from an environment variable.
  4. Parse and validate the JSON answer with a schema; reject answers that lack sources.
  5. Return the answer with sources, or a fallback message, and log the request without personal data.
  6. Run a 15-question evaluation set and record correct, incorrect and unsupported answers.

In real life

A visitor asks a training centre portal 'Which course covers SQL?'. The system finds the SQL-related course descriptions, asks the model to answer only from them and shows the answer with links to those courses.

Worked example

Problem. The helper answers 'Is there a Java course in Chennai?' although the data covers only Madurai. What went wrong and how do you reduce it?

Solution. The model answered from general knowledge or guessed, because the prompt did not force it to rely only on the retrieved text. Instruct it to answer only from the provided passages and to reply 'not found' otherwise, require source ids in the structured output, reject answers without valid ids and add this question to the evaluation set as a known failure test.

Common mistakes

  • Putting the API key in front-end code or committing it to Git.
  • Trusting model output without validation or sources.
  • Judging quality from two good examples instead of a test set that includes hard and out-of-scope questions.

Try it yourself

  • Write five out-of-scope questions your helper should refuse and the expected response.
  • List the personal data that must never be sent in a prompt and how you would remove it.

Try the questions

The same skills are asked at three levels: School (Classes 6–12), College and Professional. Switch the level and the language (English or Tamil), and say how sure you are before you check: knowing what you are unsure about is part of learning.

Classes 6–12: everyday examples, no prior knowledge. Practice only. Nothing here is graded or saved.

Question 1 / 4 · Client-server idea

When you order food in a restaurant app, which part stores the list of dishes and prices?

  1. 1App on the phone
  2. 2Server
  3. 3Database
When you order food in a restaurant app, which part stores the list of dishes and prices?
How sure are you?

Projects

Learning Centre Portal with an AI Course Helper (capstone)

A training centre needs a web portal where students browse courses, enrol and see their fees, staff manage courses and payments, and visitors can ask questions about the courses and get answers grounded in the course descriptions. Build it with Django, PostgreSQL and a React front end, with an LLM-based helper that cites its sources and admits when it does not know.

Tasks

  1. Design the database schema and ER diagram for courses, students, enrolments and payments.
  2. Build secured DRF APIs with validation, role-based permissions and consistent errors.
  3. Build a React front end with course browsing, login, enrolment and a staff fee report.
  4. Add the course helper: retrieve relevant course text, call an LLM API from the server, validate structured output, show sources and fall back to a safe message when unsure.
  5. Write pytest tests for the APIs and a 15-question evaluation set for the helper; run tests in CI.
  6. Containerise and deploy with secrets outside code, document the architecture and keep an AI-use log.

Sample input

POST /api/ask {"question": "Which course teaches SQL and how long is it?"}

Expected output

200 with JSON containing an answer, the list of course ids used as sources and a confidence flag; for a question outside the data, the answer states that it could not find it rather than guessing; no API key appears in the repository or the browser.

How it is assessed

CriterionWeight
Working features and data handling25%
API design, security and permissions20%
Front-end usability10%
GenAI feature: grounding, validation, evaluation and privacy20%
Tests, CI and deployment15%
Documentation, diagrams and demo10%

Stretch challenge: Add a feedback button on answers and use the feedback to find weak spots in the course descriptions.

Library Lending Django App (mid-course)

Build a Django application with PostgreSQL for a school library: manage books and members, lend and return books with due dates, list overdue books and expose the data through a small REST API.

Tasks

  1. Create models and migrations for Book, Member and Loan with sensible constraints.
  2. Build views, templates and a validated lending form with login for librarians.
  3. Expose books and overdue loans through DRF with permissions.
  4. Write at least ten pytest tests including double-lending and invalid input.

Sample input

Lend book 4 to member 9 on 2026-11-01 for 14 days

Expected output

A loan is created with due date 2026-11-15; lending the same book again is rejected with a clear message; the overdue list shows only loans past their due date.

How it is assessed

CriterionWeight
Correct behaviour and validation35%
Database design25%
API and permissions20%
Tests20%

Stretch challenge: Add fine calculation and a CSV export of overdue loans.

How you are assessed

Each week: a short quiz with code-reading and debugging questions, one lab task submitted through Git and a pull-request review. Fortnightly: an architecture or API-flow diagram exercise. For GenAI weeks: an evaluation table and a risk note.

Practical work. Learners submit code, SQL, test cases, diagrams and deployed links; trainers run the tests, read the history, ask design questions and set a live debugging task.

What trainers look forWeight
Correct, working features30%
Code quality, design and security20%
Tests, debugging and evaluation evidence20%
Architecture diagrams and documentation15%
Responsible AI use and collaboration15%

Where this can lead

  • Prepares you for junior Python and full-stack developer roles through a portfolio of deployed projects.
  • Builds the base for further study of data engineering, applied AI and cloud deployment.

These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.