C foundations, Python programming and OOP, SQL/MySQL, CRUD, testing, AI-assisted debugging and a database-backed application.
What you will cover
C foundations
Python programming
OOP
SQL/MySQL
CRUD
testing
AI-assisted debugging
a database-backed application
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.
The programme title is as supplied in the institute's list. Please confirm the awarding body and recognition with the institute before enrolling.
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 6 stations. Each week builds one skill you can show, not just a topic you have heard.
1
C foundations
Understand how programs use memory and build reliable C programs.
Week 1 Compilation, types and the memory model
Week 2 Control flow, functions and tracing
Week 3 Arrays, strings and bounds
Week 4 Pointers and dynamic memory
Week 5 Structures, files and debugging tools
2
Python and object-oriented design
Write well-structured Python and apply sound OOP design.
Week 6 Python essentials and collections
Week 7 Functions, files and exceptions
Week 8 Classes and encapsulation
Week 9 Design principles and patterns
Week 10 Packaging, typing and static checks
3
Database design with MySQL
Design, build and tune relational schemas.
Week 11 Relational modelling and normalisation
Week 12 MySQL DDL and CRUD
Week 13 Joins and aggregates
Week 14 Indexes, transactions and isolation
Week 15 Schema evolution and design review
4
Application architecture
Connect Python to MySQL in layers and expose a secure API.
Week 16 Python and MySQL safely
Week 17 Layered architecture
Week 18 Building a REST API
Week 19 Security basics for applications
5
Quality and team practice
Test, review, integrate and debug as a team.
Week 20 Test strategy
Week 21 Git workflow and continuous integration
Week 22 Debugging, logging and AI-assisted review
6
Capstone
Deliver and defend a database-backed application.
Week 23 Capstone build and review
Week 24 Capstone defence
★
Course Store: Layered Application
Your project, reviewed by a trainer.
The ADIVAS mastery ladder: how each skill is recognised
Explored You have seen the idea and tried a first example.
Practising You can do it with hints and keep improving.
Proficient You complete the weekly practical task correctly on your own.
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
Explain memory, pointers and compilation through C programs, and debug them with proper tools.
Write idiomatic Python with collections, files, exceptions, type hints and packages.
Apply object-oriented design: encapsulation, composition, interfaces and simple design patterns.
Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions.
Structure an application in layers and expose it through a validated REST API.
Apply security basics: parameterised SQL, password hashing, input validation and secret handling.
Plan a test strategy with unit, integration and failure tests, and use coverage and mocks sensibly.
Work in a team with Git branches, pull requests, continuous integration and verified AI-assisted debugging.
Who it suits
School Class 11-12 students who want an ambitious, structured path into how software is designed and built.
College Engineering and computer-application students who want engineering practice beyond programming syntax.
Professional Working adults and career changers who want to move into software development with sound design, testing and teamwork habits.
Prerequisites: Comfort with basic computer use and school mathematics. Prior programming is helpful but not required; weeks 1-3 build the base. Tools: GCC or Clang with GDB or LLDB, Current Python 3 with venv and pip, MySQL Community Server and MySQL Workbench, Flask or FastAPI, pytest with coverage tools, Git and GitHub with GitHub Actions, Visual Studio Code, A reputable AI coding assistant for guided, verified practice.
Weekly plan
C foundations Weeks 1–5
Week 1: Compilation, types and the memory model
Theory
Source to executable: compile, link and run
Types, sizes and printf/scanf
Stack versus heap at a conceptual level
Lab
Compile a C program with -Wall -Wextra, print the size of each basic type and draw a stack diagram for a function call.
Homework
Explain integer overflow with a worked example and demonstrate it.
Deliverable
A program set with a one-page memory diagram.
Weekly checkpoint
Predict outputs involving types and format specifiers.
You will be able to
Explain memory, pointers and compilation through C programs, and debug them with proper tools.
Week 2: Control flow, functions and tracing
Theory
Branching, loops and functions
Prototypes, scope and recursion
Dry-run tracing and assertion checks
Lab
Write number utilities (gcd, prime, digit sum) in separate functions and trace a recursive call on paper.
Homework
Write assert-based checks for each utility.
Deliverable
A utilities file with assert tests.
Weekly checkpoint
Trace a recursive function; find an off-by-one error.
You will be able to
Explain memory, pointers and compilation through C programs, and debug them with proper tools.
Week 3: Arrays, strings and bounds
Theory
Arrays, null-terminated strings
Buffer overflow and bounded input
Two-dimensional arrays
Lab
Implement search, reverse and matrix operations; show a buffer overflow in a controlled test and fix it.
Homework
Write a safe line reader with fgets.
Deliverable
An array and string library with bounds checks.
Weekly checkpoint
Find the out-of-bounds access in a listing.
You will be able to
Explain memory, pointers and compilation through C programs, and debug them with proper tools.
Week 4: Pointers and dynamic memory
Theory
Pointers, dereference and pointer arithmetic
malloc, realloc and free
Leaks, dangling pointers and ownership rules
Lab
Build a growable integer array with realloc and verify it with AddressSanitizer.
Homework
Document who owns each allocation in your code.
Deliverable
A sanitizer-clean dynamic array.
Weekly checkpoint
Draw boxes-and-arrows for pointer code; spot a use-after-free.
You will be able to
Explain memory, pointers and compilation through C programs, and debug them with proper tools.
Week 5: Structures, files and debugging tools
Theory
struct and typedef
File input and output with error checks
GDB, backtraces and Valgrind or sanitizer reports
Lab
Persist an array of student structs to a file and reload it; debug three seeded crashes with GDB.
Homework
Write a bug report for each crash with cause and fix.
Deliverable
A file-backed record program and bug reports.
Weekly checkpoint
Read a backtrace and identify the failing line.
You will be able to
Explain memory, pointers and compilation through C programs, and debug them with proper tools.
Python and object-oriented design Weeks 6–10
Week 6: Python essentials and collections
Theory
Dynamic typing, mutability and truthiness
Lists, dictionaries, sets and comprehensions
Iteration and unpacking
Lab
Analyse a list of 100 order dictionaries: totals per customer, top item, duplicate order ids.
Homework
Translate last week's C array programs to Python and compare what Python hides from you.
Deliverable
An order analysis script with comments.
Weekly checkpoint
Predict outputs on mutable defaults and aliasing.
You will be able to
Write idiomatic Python with collections, files, exceptions, type hints and packages.
Week 7: Functions, files and exceptions
Theory
Functions, arguments, generators and context managers
Reading and writing text, CSV and JSON
Exception design: catch narrowly, raise clearly
Lab
Write a robust CSV loader that reports bad rows by line number and a custom ValidationError.
Homework
Add logging with levels instead of print statements.
Deliverable
A loader library with a log output sample.
Weekly checkpoint
Fix a bare except that hides a bug.
You will be able to
Write idiomatic Python with collections, files, exceptions, type hints and packages.
Week 8: Classes and encapsulation
Theory
Classes, properties and invariants
Dataclasses, __eq__ and __repr__
Inheritance versus composition
Lab
Model Account, Transaction and Statement classes; enforce invariants and demonstrate composition over inheritance.
Homework
Refactor one inheritance chain into composition and justify it.
Deliverable
A banking model with a design note.
Weekly checkpoint
Decide between inheritance and composition for four cases.
You will be able to
Apply object-oriented design: encapsulation, composition, interfaces and simple design patterns.
Week 9: Design principles and patterns
Theory
Single responsibility, open-closed and dependency inversion in practice
Strategy and repository patterns
Coupling, cohesion and refactoring smells
Lab
Refactor a 150-line script with mixed input, rules and printing into classes using a strategy for discounts and a repository interface.
Homework
Write a short critique of the original code listing five smells.
Deliverable
A refactored program and a before/after diagram.
Weekly checkpoint
Identify a pattern from a code listing.
You will be able to
Apply object-oriented design: encapsulation, composition, interfaces and simple design patterns.
Week 10: Packaging, typing and static checks
Theory
Virtual environments, requirements and package layout
Type hints and static checking
Linting, formatting and docstrings
Lab
Turn the banking model into a package with type hints and run a linter and type checker, fixing every finding.
Homework
Write a README with install and run steps.
Deliverable
A clean, typed package.
Weekly checkpoint
Interpret a type-checker error and fix it.
You will be able to
Write idiomatic Python with collections, files, exceptions, type hints and packages. Apply object-oriented design: encapsulation, composition, interfaces and simple design patterns.
Database design with MySQL Weeks 11–15
Week 11: Relational modelling and normalisation
Theory
Entities, relationships and ER diagrams
Normal forms through worked decomposition
When to denormalise and why
Lab
Model an online course store with Students, Courses, Enrolments and Payments and justify each key.
Homework
Find the anomalies in a flat enrolment sheet and fix them by normalising.
Deliverable
An ER diagram and normalisation notes.
Weekly checkpoint
Normalise a flat table to third normal form.
You will be able to
Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions.
Week 12: MySQL DDL and CRUD
Theory
Data types, keys and constraints
INSERT, SELECT, UPDATE and DELETE
Safe update habits and soft deletes
Lab
Create the schema, load sample data and perform CRUD, triggering three constraint errors on purpose.
Homework
Write a script that rebuilds the database from scratch.
Deliverable
schema.sql and seed.sql files.
Weekly checkpoint
Predict the effect of statements on given rows.
You will be able to
Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions.
Week 13: Joins and aggregates
Theory
INNER, LEFT and self joins
GROUP BY, HAVING and window-free reporting
Subqueries versus joins
Lab
Write queries for revenue per course, students with no payment and the top three courses by enrolments.
Homework
Rewrite two subqueries as joins and compare.
Deliverable
A report query pack with expected row counts.
Weekly checkpoint
Count the rows of joins on small tables.
You will be able to
Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions.
Week 14: Indexes, transactions and isolation
Theory
B-tree indexes and EXPLAIN
ACID and transaction boundaries
Lost updates, dirty reads and isolation levels in simple terms
Lab
Compare query plans with and without an index; simulate a lost update with two sessions and fix it with a transaction and locking.
Homework
Write a note choosing indexes for five report queries.
Deliverable
An indexing note and a concurrency experiment log.
Weekly checkpoint
Explain a scenario where a transaction prevents inconsistent data.
You will be able to
Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions.
Week 15: Schema evolution and design review
Theory
Migrations as versioned scripts
Backward-compatible changes
Reviewing a schema for naming, keys and constraints
Lab
Add a Coupons table and a nullable column through versioned migration scripts, then review a peer's schema with a checklist.
Homework
Write a rollback script for each migration.
Deliverable
Migration scripts and a review report.
Weekly checkpoint
Choose a safe way to rename a column in a live system.
You will be able to
Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions. Work in a team with Git branches, pull requests, continuous integration and verified AI-assisted debugging.
Application architecture Weeks 16–19
Week 16: Python and MySQL safely
Theory
Drivers, connections and cursors
Parameterised queries and SQL injection
Connection lifecycle and error handling
Lab
Write a data-access module with parameterised queries and demonstrate an injection attempt failing.
Homework
Audit a provided script and fix every unsafe query.
Deliverable
A data-access module and an audit report.
Weekly checkpoint
Identify injection risks in a listing.
You will be able to
Apply security basics: parameterised SQL, password hashing, input validation and secret handling. Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions.
Week 17: Layered architecture
Theory
Presentation, service and data layers
Repository pattern with dependency injection by constructor
Transaction boundaries in the service layer
Lab
Structure the course store into layers; place_enrolment runs in one transaction and rolls back on payment failure.
Homework
Draw the layer diagram and mark where each rule lives.
Deliverable
A layered application skeleton with diagram.
Weekly checkpoint
Place responsibilities in the correct layer.
You will be able to
Structure an application in layers and expose it through a validated REST API. Apply object-oriented design: encapsulation, composition, interfaces and simple design patterns.
Week 18: Building a REST API
Theory
HTTP methods, status codes and idempotency
Request validation and error responses
API documentation and versioning basics
Lab
Expose courses and enrolments through Flask or FastAPI with validation and consistent JSON errors, tested with a REST client.
Homework
Write an API reference with sample requests and responses.
Deliverable
A running API with documentation.
Weekly checkpoint
Choose status codes for six scenarios.
You will be able to
Structure an application in layers and expose it through a validated REST API.
Week 19: Security basics for applications
Theory
Password hashing, not encryption
Authentication tokens and authorization checks
Secrets in environment variables and least-privilege database users
Lab
Add registration and login using a proper password-hashing library and protect write endpoints; move credentials out of source code.
Homework
Write a threat list for the app with one mitigation each.
Deliverable
A secured API and a threat list.
Weekly checkpoint
Find three security flaws in a listing.
You will be able to
Apply security basics: parameterised SQL, password hashing, input validation and secret handling.
Quality and team practice Weeks 20–22
Week 20: Test strategy
Theory
Test pyramid: unit, integration and end-to-end
Fixtures, mocks and test databases
Coverage as a signal, not a goal
Lab
Write unit tests with a mocked repository and integration tests against a test schema; deliberately break the code to confirm tests fail.
Homework
Write a test plan with risks and chosen test levels.
Deliverable
A suite of at least 25 tests and a test plan.
Weekly checkpoint
Decide the right test level for five bugs.
You will be able to
Plan a test strategy with unit, integration and failure tests, and use coverage and mocks sensibly.
Week 21: Git workflow and continuous integration
Theory
Branching strategy and pull requests
Code review etiquette and checklists
A CI workflow that runs tests and lint on every push
Lab
In pairs, create branches, review each other's pull requests and add a GitHub Actions workflow that runs the tests.
Homework
Write team working agreements: branch names, review rules and definition of done.
Deliverable
A repository with CI and reviewed pull requests.
Weekly checkpoint
Order the stages of a CI pipeline; resolve a conflict.
You will be able to
Work in a team with Git branches, pull requests, continuous integration and verified AI-assisted debugging.
Week 22: Debugging, logging and AI-assisted review
Theory
Reproduce, isolate, fix and prevent regression
Structured logging and reading production-style logs
AI help: ask for hypotheses, verify with tests, never share secrets
Lab
Diagnose three seeded production-style failures from logs; use an AI assistant for one, recording each claim and how you verified it.
Homework
Write a post-incident note for one failure.
Deliverable
Three incident notes and an AI verification log.
Weekly checkpoint
Given logs, choose the most likely root cause.
You will be able to
Plan a test strategy with unit, integration and failure tests, and use coverage and mocks sensibly. Work in a team with Git branches, pull requests, continuous integration and verified AI-assisted debugging.
Capstone Weeks 23–24
Week 23: Capstone build and review
Theory
Planning milestones and acceptance criteria
Technical debt and trade-offs
Release notes
Lab
Build the capstone in a pair, with mid-week code review and a CI check on every merge.
Homework
Prepare architecture and data model diagrams.
Deliverable
A feature-complete capstone with CI green.
Weekly checkpoint
Milestone review against acceptance criteria.
You will be able to
Structure an application in layers and expose it through a validated REST API. Plan a test strategy with unit, integration and failure tests, and use coverage and mocks sensibly. Work in a team with Git branches, pull requests, continuous integration and verified AI-assisted debugging.
Week 24: Capstone defence
Theory
Presenting architecture
Explaining trade-offs
Next steps for specialisation
Lab
Present the application, run the tests live and answer questions on schema design, transactions and security decisions.
Homework
Write a reflection with three improvements you would make.
Deliverable
Final repository, documentation and a ten-minute defence.
Weekly checkpoint
Panel evaluation using the capstone rubric.
You will be able to
Apply object-oriented design: encapsulation, composition, interfaces and simple design patterns. Design normalised MySQL schemas and write CRUD, joins, aggregates, indexes and transactions. Apply security basics: parameterised SQL, password hashing, input validation and secret handling.
Sample lessons
Week 17
Layered architecture and the transaction boundary
Layered architecture separates responsibilities. The API layer reads requests and returns responses. The service layer holds business rules and decides where a transaction starts and ends. The repository layer runs SQL. The database stores data and enforces constraints. Because each layer has one job, you can test business rules with a fake repository, change the web framework without rewriting SQL and find bugs faster. The service layer owns the transaction because only it knows which steps must succeed together.
API layer: HTTP in, JSON out
Service layer: rules and transactions
Repository layer: SQL
MySQL database: tables and constraints
Each layer has one job.
Step by step
Define a repository interface with methods such as add_enrolment and get_course.
Write EnrolmentService that receives the repository and a payment gateway in its constructor.
In enrol(), start a transaction, check capacity, record the payment and add the enrolment.
Commit on success and roll back on any exception, then raise a clear domain error.
Keep the API route thin: parse input, call the service, map errors to status codes.
Test the service with fakes before testing the API.
In real life
A college office has a front desk (API), an accounts officer who applies fee rules (service) and a records room (repository and database). The front desk never edits records directly.
Worked example
Problem. Where should the rule 'a course cannot have more than 30 students' live, and why?
Solution. In the service layer. The API only translates HTTP, and the repository only stores and fetches data. Putting the rule in the service lets it be tested without a web server and reused by any future interface. A database constraint or lock can back it up for concurrent requests.
Common mistakes
Writing SQL inside API route functions.
Starting and committing a transaction inside each repository method, so multi-step work is not atomic.
Try it yourself
Draw the layers for a library app and place five rules in the correct layer.
Write a fake repository class for testing EnrolmentService.
Week 4
Dynamic memory: allocate, use, free
Local variables live on the stack and disappear when a function returns. When you need memory whose size is known only at run time, or which must outlive a function, you ask for it from the heap with malloc and must release it yourself with free. Every successful allocation needs exactly one matching free. Forgetting it leaks memory, freeing twice corrupts the heap and using memory after free is undefined behaviour. Always check that malloc did not return NULL.
1malloc
2Check not NULL
3Use within bounds
4free once
5Set pointer to NULL
Every allocation has exactly one free.
Step by step
Include stdlib.h and request int *a = malloc(n * sizeof *a);.
Check if (a == NULL) and handle the failure.
Use the memory only within indexes 0 to n - 1.
Grow it with a temporary pointer: tmp = realloc(a, m * sizeof *a).
Call free(a) once and set a = NULL.
Run under AddressSanitizer to confirm no errors.
In real life
Renting a hall for a function: you book it, use it and must hand back the keys. Forgetting to return keys blocks others, and using the hall after returning the keys is trespass.
Worked example
Problem. Why is a = realloc(a, newSize) risky?
Solution. If realloc fails it returns NULL, and assigning that to a loses the only pointer to the old block, causing a leak. Use a temporary pointer, check it, and only then assign it to a.
Common mistakes
Using sizeof(pointer) instead of sizeof(element) when computing the size.
Returning a pointer to a local array that no longer exists.
Try it yourself
Write a function that creates a copy of a string on the heap and the code that frees it.
Find the bug: int *p = malloc(5 * sizeof(int)); p[5] = 1;
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 · Understand a function
Why do programmers put repeated steps into a function?
Projects
Course Store: Layered Application
Design and build a database-backed application for a small online course store with students, courses, enrolments and payments. It must use a normalised MySQL schema, a layered architecture, a validated REST API, secure password handling and a test suite, and be developed in a team repository with CI.
Tasks
Produce an ER diagram and migration scripts for a normalised schema.
Implement repository, service and API layers with parameterised SQL.
Make enrolment and payment recording one transaction with rollback on failure.
Add registration, login with password hashing and role checks for admin actions.
Write at least 25 tests and a GitHub Actions workflow; review each other's pull requests.
Sample input
POST /enrolments {"student_id": 4, "course_id": 2} when the payment step fails
Expected output
The API returns an error response, no enrolment row exists, the transaction is rolled back and the failure is logged.
How it is assessed
Criterion
Weight
Schema design and migrations
20%
Architecture and code quality
20%
Security and transactions
20%
Test strategy and CI
20%
Team practice and documentation
20%
Stretch challenge: Add a reporting endpoint with an index chosen using EXPLAIN.
Memory-Safe C Record Store
Write a C program that stores up to a few thousand student records in a growable array, saves and loads them from a file and never leaks memory or overflows buffers. Then write a Python script that reads the same file and checks it for corruption.
Tasks
Implement a dynamic array of structs with add, find and remove.
Save and load with checked file operations.
Run with AddressSanitizer and fix all findings.
Write a Python validator that reports malformed lines.
Sample input
101,Anu,92
102,Bala,
Expected output
The C program loads valid records and reports line 2 as malformed; the sanitizer prints no errors.
How it is assessed
Criterion
Weight
Memory safety
35%
Correct file handling
25%
Python validator
20%
Tests and documentation
20%
Stretch challenge: Add binary file format with a version header.
How you are assessed
Each week: a quiz with code reading, output or error prediction and a design or debugging item; a lab committed to Git and reviewed by a trainer or peer. Module ends add a short design-and-defend task where learners justify choices.
Practical work. Learners are assessed on running, tested code, peer-reviewed pull requests, a CI-checked repository and a capstone defence covering schema, architecture, transactions, security and test strategy.
What trainers look for
Weight
Correct, working code across C, Python and SQL
25%
Design and architecture quality
20%
Testing and debugging evidence
20%
Security and data integrity
15%
Team practice and responsible AI use
20%
Where this can lead
Prepares you for junior software engineer and backend developer roles.
Prepares you for database-backed application and quality-focused development work.
Builds the base for further study in cloud, distributed systems and advanced architecture.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
