Python Full Stack — Expert Programme
Expert-level practical training in Python Full Stack, structured into 24 sequenced modules with hands-on exercises, guided projects and a capstone. Curriculum and course details are drafts pending academic review.
Book a Free Demo →Course overview
Expert-level practical training in Python Full Stack, structured into 24 sequenced modules with hands-on exercises, guided projects and a capstone. Curriculum and course details are drafts pending academic review.
Who can join?
Learners seeking structured, practical skills in Python Full Stack; final eligibility and guidance will be confirmed by the training team.
Prerequisites
Basic computer literacy. Module-specific prerequisites are covered in the course roadmap; final entry criteria require trainer review.
Practical projects
Hands-on practical exercises across 24 modules in Python Full Stack, followed by an integrated portfolio/capstone project. Final projects, assessment rubrics and industry relevance require trainer approval.
Classroom curriculum
01Computer & Developer Foundations7.5 hrs
Learn computer & developer foundations through structured practical training at IDM Technologies, Vallioor. Cover computing and professional workflow, files, paths and command line, editor and browser developer tools, and documentation and debugging habits. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Computing and professional workflow: Operating systems; files and extensions; project naming; safe sample data Files, paths and command line: Absolute/relative paths; cd, dir/ls, mkdir; safe operations Editor and browser developer tools: VS Code workspace; extensions; search; browser inspector; console Documentation and debugging habits: Official docs; version checks; minimal reproduction; error logs Workstation assessment: Folder organization; reproducibility; documentation; submission
Learning outcomes
Explain computing and professional workflow and distinguish correct use from a common misconception. Explain files, paths and command line and distinguish correct use from a common misconception. Explain editor and browser developer tools and distinguish correct use from a common misconception. Explain documentation and debugging habits and distinguish correct use from a common misconception. Explain workstation assessment and distinguish correct use from a common misconception. Apply Computing and professional workflow, Files, paths and command line, Editor and browser developer tools to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the computer & developer foundations deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Computing and professional workflow: Create the developer workspace and three project folders. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Files, paths and command line: Navigate and create nested project directories from the terminal. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Editor and browser developer tools: Configure editor and inspect a sample web page. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Documentation and debugging habits: Reproduce a setup task and record troubleshooting steps. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Workstation assessment: Demonstrate a clean reproducible workspace. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Computing and professional workflow: Draw the initial requirements, user personas and one-page scope for all three portfolio projects. Independent task 2 — Files, paths and command line: Recreate the project directories entirely with commands and capture the command log. Independent task 3 — Editor and browser developer tools: Prepare README files and a development-environment checklist for each portfolio project. Independent task 4 — Documentation and debugging habits: Write user stories and acceptance criteria for one feature in each project. Independent task 5 — Workstation assessment: Submit all three project charters, folder trees and setup notes.
02HTML5 & Modern CSS7.5 hrs
Learn html5 & modern css through structured practical training at IDM Technologies, Vallioor. Cover semantic html structure, html forms and accessibility, css foundations, and responsive layout. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Semantic HTML structure: Doctype; sections; headings; links; images; semantic regions HTML forms and accessibility: Labels; input types; required constraints; alt text; keyboard structure CSS foundations: Selectors; cascade; specificity; colors; spacing; box model Responsive layout: Flexbox; Grid; media queries; fluid units; navigation Web foundations assessment: Semantic check; keyboard navigation; responsive breakpoints
Learning outcomes
Explain semantic html structure and distinguish correct use from a common misconception. Explain html forms and accessibility and distinguish correct use from a common misconception. Explain css foundations and distinguish correct use from a common misconception. Explain responsive layout and distinguish correct use from a common misconception. Explain web foundations assessment and distinguish correct use from a common misconception. Apply Semantic HTML structure, HTML forms and accessibility, CSS foundations to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the html5 & modern css deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Semantic HTML structure: Create a multi-section static course page. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — HTML forms and accessibility: Build a labelled admission/enquiry form. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — CSS foundations: Style an accessible responsive information page. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Responsive layout: Build responsive cards and layout for mobile/desktop. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Web foundations assessment: Demonstrate three responsive static screens. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Semantic HTML structure: Mark up a homepage skeleton for the Institute Management project. Independent task 2 — HTML forms and accessibility: Create accessible candidate and employer registration forms for the Job Portal. Independent task 3 — CSS foundations: Build a consistent typography and spacing stylesheet for all three projects. Independent task 4 — Responsive layout: Create a responsive job-listing page and a service-catalogue page. Independent task 5 — Web foundations assessment: Submit validated HTML/CSS layouts and screenshots for the three portfolio project shells.
03Bootstrap & Tailwind CSS7.5 hrs
Learn bootstrap & tailwind css through structured practical training at IDM Technologies, Vallioor. Cover bootstrap setup and grid, bootstrap components, tailwind fundamentals, and tailwind responsive interfaces. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Bootstrap setup and grid: Bootstrap imports; containers; columns; breakpoints Bootstrap components: Navigation; cards; modals; forms; validation feedback Tailwind fundamentals: Installation; utility classes; spacing; typography; design tokens Tailwind responsive interfaces: Responsive variants; flex/grid; hover/focus; reusable patterns Framework comparison and assessment: Tradeoffs; consistency; customization; QA
Learning outcomes
Explain bootstrap setup and grid and distinguish correct use from a common misconception. Explain bootstrap components and distinguish correct use from a common misconception. Explain tailwind fundamentals and distinguish correct use from a common misconception. Explain tailwind responsive interfaces and distinguish correct use from a common misconception. Explain framework comparison and assessment and distinguish correct use from a common misconception. Apply Bootstrap setup and grid, Bootstrap components, Tailwind fundamentals to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the bootstrap & tailwind css deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Bootstrap setup and grid: Convert a static page to Bootstrap grid. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Bootstrap components: Create Bootstrap form and table UI. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Tailwind fundamentals: Create a Tailwind design system sample. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Tailwind responsive interfaces: Build accessible responsive Tailwind components. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Framework comparison and assessment: Compare equivalent UI in both frameworks. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Bootstrap setup and grid: Build a responsive Institute dashboard shell with Bootstrap. Independent task 2 — Bootstrap components: Add an admission form and fee-summary cards to the Institute project. Independent task 3 — Tailwind fundamentals: Style a Job Portal landing page with Tailwind. Independent task 4 — Tailwind responsive interfaces: Build the Service Booking catalogue and enquiry screens using Tailwind. Independent task 5 — Framework comparison and assessment: Submit three styled portfolio UI kits with mobile screenshots.
04JavaScript Fundamentals7.5 hrs
Learn javascript fundamentals through structured practical training at IDM Technologies, Vallioor. Cover javascript variables and operations, control flow and functions, arrays and objects, and dom and browser events. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
JavaScript variables and operations: let/const; primitives; conversion; comparisons; operators Control flow and functions: if/switch; loops; functions; parameters; scope Arrays and objects: Array methods; object properties; nested records DOM and browser events: querySelector; events; form input; validation; safe text rendering JavaScript module assessment: Debugging; function reuse; defensive input checks
Learning outcomes
Explain javascript variables and operations and distinguish correct use from a common misconception. Explain control flow and functions and distinguish correct use from a common misconception. Explain arrays and objects and distinguish correct use from a common misconception. Explain dom and browser events and distinguish correct use from a common misconception. Explain javascript module assessment and distinguish correct use from a common misconception. Apply JavaScript variables and operations, Control flow and functions, Arrays and objects to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the javascript fundamentals deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — JavaScript variables and operations: Create interactive input/output examples. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Control flow and functions: Write condition and loop exercises. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Arrays and objects: Render data from in-memory arrays. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — DOM and browser events: Create interactive search and validation. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — JavaScript module assessment: Present a working dynamic static-page feature. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — JavaScript variables and operations: Calculate an admission fee summary with basic JavaScript. Independent task 2 — Control flow and functions: Implement job category filters using loops and conditions. Independent task 3 — Arrays and objects: Create in-memory student, job and service data records. Independent task 4 — DOM and browser events: Add client-side job search and service price calculator. Independent task 5 — JavaScript module assessment: Submit a reusable JS utility file plus interactive feature in each portfolio.
05Advanced JavaScript & TypeScript7.5 hrs
Learn advanced javascript & typescript through structured practical training at IDM Technologies, Vallioor. Cover modern javascript syntax, promises and async/await, web apis and json, and typescript essentials. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Modern JavaScript syntax: Destructuring; spread/rest; map/filter/reduce; imports/exports Promises and async/await: Promise states; async functions; try/catch; loading states Web APIs and JSON: Fetch; HTTP basics; JSON parse/stringify; response checks TypeScript essentials: Primitive types; arrays; interfaces; unions; optional properties TypeScript integration: Compile workflow; typed functions; typed API results
Learning outcomes
Explain modern javascript syntax and distinguish correct use from a common misconception. Explain promises and async/await and distinguish correct use from a common misconception. Explain web apis and json and distinguish correct use from a common misconception. Explain typescript essentials and distinguish correct use from a common misconception. Explain typescript integration and distinguish correct use from a common misconception. Apply Modern JavaScript syntax, Promises and async/await, Web APIs and JSON to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the advanced javascript & typescript deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Modern JavaScript syntax: Refactor JS utilities into modules. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Promises and async/await: Fetch and render public/sample JSON data. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Web APIs and JSON: Build resilient API loading with mock data. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — TypeScript essentials: Type a student and job record. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — TypeScript integration: Deliver typed search/filter utility. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Modern JavaScript syntax: Convert the Institute dataset helpers to modular JavaScript. Independent task 2 — Promises and async/await: Load mock job listings asynchronously with loading/error screens. Independent task 3 — Web APIs and JSON: Add mocked service catalogue API consumption. Independent task 4 — TypeScript essentials: Define shared TypeScript interfaces for all three portfolio data models. Independent task 5 — TypeScript integration: Submit typed asynchronous interface with tests for edge cases.
06React.js Fundamentals7.5 hrs
Learn react.js fundamentals through structured practical training at IDM Technologies, Vallioor. Cover react environment and jsx, props and composition, state and events, and lists, forms and rendering. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
React environment and JSX: Vite; component tree; JSX; assets Props and composition: Props; reusable cards; component layout State and events: useState; event callbacks; derived state Lists, forms and rendering: Keys; conditional rendering; controlled inputs React foundations assessment: Component isolation; DevTools; predictable updates
Learning outcomes
Explain react environment and jsx and distinguish correct use from a common misconception. Explain props and composition and distinguish correct use from a common misconception. Explain state and events and distinguish correct use from a common misconception. Explain lists, forms and rendering and distinguish correct use from a common misconception. Explain react foundations assessment and distinguish correct use from a common misconception. Apply React environment and JSX, Props and composition, State and events to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the react.js fundamentals deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — React environment and JSX: Create a React starter and first functional components. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Props and composition: Develop reusable cards and header components. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — State and events: Implement interactive filter and counter. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Lists, forms and rendering: Create a controlled application form. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — React foundations assessment: Demonstrate an interactive React mini-app. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — React environment and JSX: Initialize React UI shells for Institute, Job Portal and Service Booking. Independent task 2 — Props and composition: Build a course card and job listing card using props. Independent task 3 — State and events: Add enrolment-status and booking-selection interactions. Independent task 4 — Lists, forms and rendering: Build React forms for admission and job application. Independent task 5 — React foundations assessment: Submit usable React page shells for all three projects.
07Advanced React & Frontend Integration7.5 hrs
Learn advanced react & frontend integration through structured practical training at IDM Technologies, Vallioor. Cover client-side routes, shared state and hooks, forms and validation, and data fetching and errors. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Client-side routes: React Router; layout routes; navigation; not-found page Shared state and hooks: Context; custom hooks; derived state; state location Forms and validation: Controlled forms; field errors; submit state Data fetching and errors: Fetch; loading/empty/error; async effects; cancellation awareness Advanced React assessment: Component tests introduction; accessibility; organization
Learning outcomes
Explain client-side routes and distinguish correct use from a common misconception. Explain shared state and hooks and distinguish correct use from a common misconception. Explain forms and validation and distinguish correct use from a common misconception. Explain data fetching and errors and distinguish correct use from a common misconception. Explain advanced react assessment and distinguish correct use from a common misconception. Apply Client-side routes, Shared state and hooks, Forms and validation to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the advanced react & frontend integration deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Client-side routes: Add multi-page navigation. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Shared state and hooks: Build shared UI state and hook. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Forms and validation: Build robust application form. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Data fetching and errors: Connect to a local mock API. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Advanced React assessment: Review and refactor a React UI. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Client-side routes: Create routes for students, candidates and customers. Independent task 2 — Shared state and hooks: Add shared authentication UI placeholders (not security enforcement). Independent task 3 — Forms and validation: Create candidate profile and service-booking validation flows. Independent task 4 — Data fetching and errors: Load dashboard metrics and job listings from mock endpoints. Independent task 5 — Advanced React assessment: Demonstrate a coherent multi-page React prototype for all three projects.
08Git, GitHub & Team Collaboration7.5 hrs
Learn git, github & team collaboration through structured practical training at IDM Technologies, Vallioor. Cover git fundamentals, history and collaboration, branches and merging, and github workflow. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Git fundamentals: init; status; add; commit; .gitignore History and collaboration: log; diff; clean commit messages; branching Branches and merging: Feature branches; merge; resolving conflicts GitHub workflow: Remotes; push; pull requests; reviews; issues Professional repo assessment: Release tags; contribution notes; documentation
Learning outcomes
Explain git fundamentals and distinguish correct use from a common misconception. Explain history and collaboration and distinguish correct use from a common misconception. Explain branches and merging and distinguish correct use from a common misconception. Explain github workflow and distinguish correct use from a common misconception. Explain professional repo assessment and distinguish correct use from a common misconception. Apply Git fundamentals, History and collaboration, Branches and merging to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the git, github & team collaboration deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Git fundamentals: Create the first tracked local repository. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — History and collaboration: Commit a focused UI feature. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Branches and merging: Resolve a practice branch conflict. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — GitHub workflow: Open and review a pull request. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Professional repo assessment: Demonstrate tracked change from issue to merge. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Git fundamentals: Initialize Git repositories for all three portfolio projects. Independent task 2 — History and collaboration: Commit the existing UI history and document milestones. Independent task 3 — Branches and merging: Implement one portfolio feature in a dedicated branch. Independent task 4 — GitHub workflow: Publish all three repositories with README and issue backlogs. Independent task 5 — Professional repo assessment: Submit GitHub links, issue boards and project roadmaps.
09Python Programming Fundamentals7.5 hrs
Learn python programming fundamentals through structured practical training at IDM Technologies, Vallioor. Cover python setup and syntax, operators and branching, loops and patterns, and functions and scope. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Python setup and syntax: Interpreter; pip; virtual environment basics; variables; print/input Operators and branching: Comparison; logical operators; if/elif/else Loops and patterns: for/while; range; break/continue; nested loops Functions and scope: Parameters; return; defaults; local scope Python fundamentals assessment: Trace/debug; input safety; edge cases
Learning outcomes
Explain python setup and syntax and distinguish correct use from a common misconception. Explain operators and branching and distinguish correct use from a common misconception. Explain loops and patterns and distinguish correct use from a common misconception. Explain functions and scope and distinguish correct use from a common misconception. Explain python fundamentals assessment and distinguish correct use from a common misconception. Apply Python setup and syntax, Operators and branching, Loops and patterns to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the python programming fundamentals deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Python setup and syntax: Run Python calculations and types demo. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Operators and branching: Implement validation and decision problems. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Loops and patterns: Solve loop exercises with trace tables. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Functions and scope: Refactor procedural scripts to functions. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Python fundamentals assessment: Complete unseen coding problems independently. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Python setup and syntax: Write a simple command-line admission fee calculator. Independent task 2 — Operators and branching: Write job eligibility checks based on sample criteria. Independent task 3 — Loops and patterns: Process a list of booking requests and summarize counts. Independent task 4 — Functions and scope: Create reusable helpers for fee, job and service calculations. Independent task 5 — Python fundamentals assessment: Submit a tested command-line utility with examples and documentation.
10Python Data Structures & File Handling7.5 hrs
Learn python data structures & file handling through structured practical training at IDM Technologies, Vallioor. Cover core data structures, data manipulation, files and paths, and csv, json and exceptions. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Core data structures: List; tuple; set; dictionary; indexing Data manipulation: Slicing; sorting; comprehensions; strings Files and paths: with/open; read/write; encoding; pathlib CSV, JSON and exceptions: csv/json modules; try/except; validation Data-processing assessment: Edge cases; data quality; small tests
Learning outcomes
Explain core data structures and distinguish correct use from a common misconception. Explain data manipulation and distinguish correct use from a common misconception. Explain files and paths and distinguish correct use from a common misconception. Explain csv, json and exceptions and distinguish correct use from a common misconception. Explain data-processing assessment and distinguish correct use from a common misconception. Apply Core data structures, Data manipulation, Files and paths to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the python data structures & file handling deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Core data structures: Write transformations on nested data. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Data manipulation: Clean and filter sample records. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Files and paths: Read and write structured text files. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — CSV, JSON and exceptions: Transform CSV to JSON safely. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Data-processing assessment: Demonstrate a file-backed CLI utility. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Core data structures: Represent students, applications and bookings as Python dictionaries. Independent task 2 — Data manipulation: Build a candidate filtering script and service-search helper. Independent task 3 — Files and paths: Export admission records to CSV with safe paths. Independent task 4 — CSV, JSON and exceptions: Write import/export scripts for job applications and bookings. Independent task 5 — Data-processing assessment: Submit reusable data utilities for the three projects.
11Python OOP & Advanced Programming7.5 hrs
Learn python oop & advanced programming through structured practical training at IDM Technologies, Vallioor. Cover classes and objects, oop design, packages and environments, and advanced python tools. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Classes and objects: Constructors; methods; instance/class data OOP design: Inheritance; composition; encapsulation; polymorphism Packages and environments: Modules; imports; virtualenv; dependencies; pyproject overview Advanced Python tools: Iterators; generators; decorators; context managers Quality and typing: Type hints; dataclasses; small unit tests
Learning outcomes
Explain classes and objects and distinguish correct use from a common misconception. Explain oop design and distinguish correct use from a common misconception. Explain packages and environments and distinguish correct use from a common misconception. Explain advanced python tools and distinguish correct use from a common misconception. Explain quality and typing and distinguish correct use from a common misconception. Apply Classes and objects, OOP design, Packages and environments to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the python oop & advanced programming deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Classes and objects: Model entities as Python classes. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — OOP design: Implement service classes with validation. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Packages and environments: Extract helpers into a package. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Advanced Python tools: Write generator and decorator examples. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Quality and typing: Test and review object-oriented code. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Classes and objects: Define Student, JobApplication and Booking domain models. Independent task 2 — OOP design: Create reusable domain services for fee and booking rules. Independent task 3 — Packages and environments: Organize the three backend prototypes into reusable Python packages. Independent task 4 — Advanced Python tools: Implement a trace decorator and generator-based data export. Independent task 5 — Quality and typing: Submit typed backend domain models with a few automated tests.
12Python DSA & Problem Solving7.5 hrs
Learn python dsa & problem solving through structured practical training at IDM Technologies, Vallioor. Cover algorithmic reasoning, strings and collections, stacks, queues and recursion, and searching and sorting. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Algorithmic reasoning: Big-O; tradeoffs; common complexity classes Strings and collections: String problems; frequency maps; hash sets Stacks, queues and recursion: Stack; queue; recursive base cases Searching and sorting: Linear/binary search; sorting; stability Problem-solving assessment: Unseen coding tasks; explanation; testing
Learning outcomes
Explain algorithmic reasoning and distinguish correct use from a common misconception. Explain strings and collections and distinguish correct use from a common misconception. Explain stacks, queues and recursion and distinguish correct use from a common misconception. Explain searching and sorting and distinguish correct use from a common misconception. Explain problem-solving assessment and distinguish correct use from a common misconception. Apply Algorithmic reasoning, Strings and collections, Stacks, queues and recursion to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the python dsa & problem solving deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Algorithmic reasoning: Compare linear and quadratic implementations. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Strings and collections: Solve string and dictionary interview problems. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Stacks, queues and recursion: Implement task queue and simple recursive solutions. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Searching and sorting: Benchmark search and sort variations. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Problem-solving assessment: Complete timed independent problem set. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Algorithmic reasoning: Document expected growth of applicant search operations. Independent task 2 — Strings and collections: Add duplicate detection for student/candidate records. Independent task 3 — Stacks, queues and recursion: Prototype an ordered booking waitlist. Independent task 4 — Searching and sorting: Add sorting and searchable indexing to sample job data. Independent task 5 — Problem-solving assessment: Commit documented algorithms and explain one portfolio optimization.
13SQL & PostgreSQL7.5 hrs
Learn sql & postgresql through structured practical training at IDM Technologies, Vallioor. Cover relational model and postgresql, sql crud and filtering, joins and relational design, and transactions and indexes. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Relational model and PostgreSQL: Schemas; types; primary/foreign keys; setup SQL CRUD and filtering: SELECT; INSERT/UPDATE/DELETE; WHERE; ORDER BY; aggregates Joins and relational design: Inner/left joins; grouping; normalization; constraints Transactions and indexes: ACID; BEGIN/COMMIT/ROLLBACK; query plans Database assessment: Migrations concept; backups; restore; SQL debugging
Learning outcomes
Explain relational model and postgresql and distinguish correct use from a common misconception. Explain sql crud and filtering and distinguish correct use from a common misconception. Explain joins and relational design and distinguish correct use from a common misconception. Explain transactions and indexes and distinguish correct use from a common misconception. Explain database assessment and distinguish correct use from a common misconception. Apply Relational model and PostgreSQL, SQL CRUD and filtering, Joins and relational design to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the sql & postgresql deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Relational model and PostgreSQL: Install PostgreSQL and create schema. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — SQL CRUD and filtering: Query populated sample tables. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Joins and relational design: Generate joined reports. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Transactions and indexes: Demonstrate rollback and index evaluation. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Database assessment: Review and demonstrate a query-driven database. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Relational model and PostgreSQL: Design ERDs for students, jobs/applications and service bookings. Independent task 2 — SQL CRUD and filtering: Create PostgreSQL tables and sample records for all three projects. Independent task 3 — Joins and relational design: Write queries for admission status, applied jobs and customer bookings. Independent task 4 — Transactions and indexes: Add transaction-safe booking or fee-record workflow. Independent task 5 — Database assessment: Submit SQL scripts, ERDs and recovery notes for each project.
14Flask Web Development7.5 hrs
Learn flask web development through structured practical training at IDM Technologies, Vallioor. Cover flask setup and routes, templates and forms, persistence and crud, and blueprints and sessions. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Flask setup and routes: Flask app; route decorators; URL parameters Templates and forms: Jinja inheritance; request data; form validation Persistence and CRUD: PostgreSQL connection; safe SQL/ORM intro; CRUD Blueprints and sessions: Blueprint organization; session basics; config Flask assessment: Error pages; tests; secure configuration
Learning outcomes
Explain flask setup and routes and distinguish correct use from a common misconception. Explain templates and forms and distinguish correct use from a common misconception. Explain persistence and crud and distinguish correct use from a common misconception. Explain blueprints and sessions and distinguish correct use from a common misconception. Explain flask assessment and distinguish correct use from a common misconception. Apply Flask setup and routes, Templates and forms, Persistence and CRUD to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the flask web development deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Flask setup and routes: Start a Flask service with core routes. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Templates and forms: Build a server-rendered enquiry form. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Persistence and CRUD: Implement a small CRUD flow. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Blueprints and sessions: Refactor app into blueprints. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Flask assessment: Demonstrate small Flask web app. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Flask setup and routes: Build a lightweight service enquiry prototype. Independent task 2 — Templates and forms: Create a public service-booking form and confirmation view. Independent task 3 — Persistence and CRUD: Persist enquiries and display filtered records. Independent task 4 — Blueprints and sessions: Separate public enquiry and staff listing functions. Independent task 5 — Flask assessment: Submit a documented Flask service prototype with test evidence.
15Django Framework Fundamentals7.5 hrs
Learn django framework fundamentals through structured practical training at IDM Technologies, Vallioor. Cover django project structure, url routing and views, templates and static files, and application configuration. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Django project structure: startproject/startapp; settings; apps; MVT URL routing and views: path/include; view functions; responses; redirects Templates and static files: Template inheritance; filters; static/media overview Application configuration: Environment config; DEBUG; installed apps; logs Django foundations assessment: Request cycle; errors; architectural boundaries
Learning outcomes
Explain django project structure and distinguish correct use from a common misconception. Explain url routing and views and distinguish correct use from a common misconception. Explain templates and static files and distinguish correct use from a common misconception. Explain application configuration and distinguish correct use from a common misconception. Explain django foundations assessment and distinguish correct use from a common misconception. Apply Django project structure, URL routing and views, Templates and static files to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the django framework fundamentals deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Django project structure: Initialize Django project and run checks. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — URL routing and views: Build list and detail endpoints. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Templates and static files: Create a template-based course catalogue. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Application configuration: Split safe local configuration. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Django foundations assessment: Demonstrate Django routing and templates. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Django project structure: Start the Institute application Django backend. Independent task 2 — URL routing and views: Add course list/detail routes to Institute backend. Independent task 3 — Templates and static files: Prototype Institute public pages from Django templates. Independent task 4 — Application configuration: Document safe project settings for all portfolio backends. Independent task 5 — Django foundations assessment: Submit Django project skeleton with documented routes.
16Django ORM & Database Integration7.5 hrs
Learn django orm & database integration through structured practical training at IDM Technologies, Vallioor. Cover models and fields, migrations, relationships and querysets, and admin and data quality. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Models and fields: ORM mapping; fields; validators; schema design Migrations: makemigrations; migrate; schema history Relationships and QuerySets: ForeignKey; M2M; filtering; aggregation Admin and data quality: Admin registrations; validation; fixtures ORM assessment: N+1 basics; select_related; transactions overview
Learning outcomes
Explain models and fields and distinguish correct use from a common misconception. Explain migrations and distinguish correct use from a common misconception. Explain relationships and querysets and distinguish correct use from a common misconception. Explain admin and data quality and distinguish correct use from a common misconception. Explain orm assessment and distinguish correct use from a common misconception. Apply Models and fields, Migrations, Relationships and QuerySets to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the django orm & database integration deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Models and fields: Build Course and Student models. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Migrations: Apply and inspect migrations. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Relationships and QuerySets: Query related records. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Admin and data quality: Configure admin and sample fixtures. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — ORM assessment: Review and optimize query examples. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Models and fields: Model Institute students/courses and job/application entities. Independent task 2 — Migrations: Create repeatable PostgreSQL migrations for Institute backend. Independent task 3 — Relationships and QuerySets: Implement job application, enrolment and booking relations. Independent task 4 — Admin and data quality: Add admin workflows for programmes and job listings. Independent task 5 — ORM assessment: Submit ORM-based CRUD demonstration with sample data.
17Django Authentication & Application Security7.5 hrs
Learn django authentication & application security through structured practical training at IDM Technologies, Vallioor. Cover forms and validation, login and sessions, authorization, and web security practice. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Forms and validation: Forms/ModelForms; validation rules; error messages Login and sessions: Django auth; password hashing; login/logout Authorization: Groups; permissions; object-level checks; least privilege Web security practice: CSRF; XSS; SQL injection; upload validation; secrets Security assessment: Privacy; logs; dependency updates; tests
Learning outcomes
Explain forms and validation and distinguish correct use from a common misconception. Explain login and sessions and distinguish correct use from a common misconception. Explain authorization and distinguish correct use from a common misconception. Explain web security practice and distinguish correct use from a common misconception. Explain security assessment and distinguish correct use from a common misconception. Apply Forms and validation, Login and sessions, Authorization to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the django authentication & application security deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Forms and validation: Build validated registration form. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Login and sessions: Implement a staff login flow. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Authorization: Protect staff/admin endpoints. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Web security practice: Fix intentional security flaws in a sample. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Security assessment: Demonstrate denied-access cases. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Forms and validation: Add admission and candidate registration validation. Independent task 2 — Login and sessions: Add secure login to the Institute backend. Independent task 3 — Authorization: Create candidate/employer and customer/staff role policies. Independent task 4 — Web security practice: Threat-model applications and secure form/permission boundaries. Independent task 5 — Security assessment: Submit role matrix, threat checklist and security test evidence.
18REST APIs & Django REST Framework7.5 hrs
Learn rest apis & django rest framework through structured practical training at IDM Technologies, Vallioor. Cover rest and http, serializers and views, routers and permissions, and filtering, pagination and documentation. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
REST and HTTP: Resource design; verbs; status codes; JSON; idempotency Serializers and views: DRF serializers; APIViews/viewsets; validation Routers and permissions: Routers; auth approaches; permission classes Filtering, pagination and documentation: Query params; filters; pagination; schema/docs API assessment: Postman collections; automated API checks; error cases
Learning outcomes
Explain rest and http and distinguish correct use from a common misconception. Explain serializers and views and distinguish correct use from a common misconception. Explain routers and permissions and distinguish correct use from a common misconception. Explain filtering, pagination and documentation and distinguish correct use from a common misconception. Explain api assessment and distinguish correct use from a common misconception. Apply REST and HTTP, Serializers and views, Routers and permissions to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the rest apis & django rest framework deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — REST and HTTP: Design API contract and error format. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Serializers and views: Build course CRUD endpoints. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Routers and permissions: Protect role-specific API routes. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Filtering, pagination and documentation: Implement searchable paginated list API. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — API assessment: Test success/invalid/unauthorized requests. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — REST and HTTP: Specify API routes for admissions, jobs/applications and bookings. Independent task 2 — Serializers and views: Expose Institute student/course CRUD APIs. Independent task 3 — Routers and permissions: Implement employer/candidate job permissions. Independent task 4 — Filtering, pagination and documentation: Add search/pagination to job and service APIs. Independent task 5 — API assessment: Submit three API contracts and runnable request collections.
19FastAPI & Modern API Development7.5 hrs
Learn fastapi & modern api development through structured practical training at IDM Technologies, Vallioor. Cover fastapi and routing, pydantic validation, dependencies and modularization, and async and persistence. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
FastAPI and routing: ASGI concept; path/query parameters; response models Pydantic validation: Typed models; field constraints; clear errors Dependencies and modularization: Depends; APIRouter; clean boundaries Async and persistence: async def basics; blocking pitfalls; database access concepts FastAPI assessment: OpenAPI docs; testing; exception handlers
Learning outcomes
Explain fastapi and routing and distinguish correct use from a common misconception. Explain pydantic validation and distinguish correct use from a common misconception. Explain dependencies and modularization and distinguish correct use from a common misconception. Explain async and persistence and distinguish correct use from a common misconception. Explain fastapi assessment and distinguish correct use from a common misconception. Apply FastAPI and routing, Pydantic validation, Dependencies and modularization to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the fastapi & modern api development deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — FastAPI and routing: Create documented API endpoints. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Pydantic validation: Build validation-rich request models. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Dependencies and modularization: Refactor routes into modules. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Async and persistence: Build controlled async endpoint example. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — FastAPI assessment: Demonstrate tested documented service API. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — FastAPI and routing: Prototype service availability API. Independent task 2 — Pydantic validation: Validate bookings and customer payloads. Independent task 3 — Dependencies and modularization: Add reusable validation/auth dependency to prototype. Independent task 4 — Async and persistence: Connect a FastAPI prototype to safe persistence layer. Independent task 5 — FastAPI assessment: Submit the FastAPI service prototype and explanation of Django vs FastAPI choices.
20Full Stack Integration7.5 hrs
Learn full stack integration through structured practical training at IDM Technologies, Vallioor. Cover system integration architecture, authentication flow, forms and mutations, and search, pagination and ux. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
System integration architecture: Frontend/backend separation; API contracts; env config Authentication flow: Session/token concepts; credential handling; protected routes Forms and mutations: POST/PATCH/DELETE; validation; optimistic state cautions Search, pagination and UX: Query parameters; loading/error states; CORS Integration assessment: Contract tests; tracing requests; network inspector
Learning outcomes
Explain system integration architecture and distinguish correct use from a common misconception. Explain authentication flow and distinguish correct use from a common misconception. Explain forms and mutations and distinguish correct use from a common misconception. Explain search, pagination and ux and distinguish correct use from a common misconception. Explain integration assessment and distinguish correct use from a common misconception. Apply System integration architecture, Authentication flow, Forms and mutations to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the full stack integration deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — System integration architecture: Connect React client to DRF endpoint. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Authentication flow: Create safe login and protected UI. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Forms and mutations: Implement functional create/edit form. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Search, pagination and UX: Build paginated searchable React list. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Integration assessment: Diagnose and fix integration failures. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — System integration architecture: Connect Institute React UI to student/course APIs. Independent task 2 — Authentication flow: Connect candidate/employer authentication to job APIs. Independent task 3 — Forms and mutations: Connect service booking forms and confirmation flow. Independent task 4 — Search, pagination and UX: Implement job filters and admission search in integrated UI. Independent task 5 — Integration assessment: Demonstrate end-to-end create/list/update flows across portfolios.
21Testing, Debugging & Code Quality7.5 hrs
Learn testing, debugging & code quality through structured practical training at IDM Technologies, Vallioor. Cover testing strategy and pytest, django and api tests, react component testing, and debugging and code quality. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Testing strategy and pytest: Test pyramid; fixtures; assertions; edge cases Django and API tests: Django TestCase; DRF APIClient; permissions tests React component testing: User-centric interaction tests; mocks; accessible queries Debugging and code quality: Logging; breakpoints; linting; formatting; refactor QA assessment: Coverage as guide; CI-ready commands; test plans
Learning outcomes
Explain testing strategy and pytest and distinguish correct use from a common misconception. Explain django and api tests and distinguish correct use from a common misconception. Explain react component testing and distinguish correct use from a common misconception. Explain debugging and code quality and distinguish correct use from a common misconception. Explain qa assessment and distinguish correct use from a common misconception. Apply Testing strategy and pytest, Django and API tests, React component testing to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the testing, debugging & code quality deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Testing strategy and pytest: Write Python unit tests. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Django and API tests: Test unauthorized and validation responses. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — React component testing: Test form interaction and loading. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Debugging and code quality: Debug a seeded defect and fix it. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — QA assessment: Review tests and evidence. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Testing strategy and pytest: Test fee calculations, candidate filters and booking rules. Independent task 2 — Django and API tests: Add integration tests to all three applications. Independent task 3 — React component testing: Add UI tests for key forms and searches. Independent task 4 — Debugging and code quality: Refactor repeated project code and document changes. Independent task 5 — QA assessment: Submit test suites and defect logs for each portfolio.
22Docker, Deployment & CI/CD7.5 hrs
Learn docker, deployment & ci/cd through structured practical training at IDM Technologies, Vallioor. Cover linux and deployment foundations, docker images and containers, docker compose, and ci/cd and hosting. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Linux and deployment foundations: Shell; environment variables; processes; reverse proxies Docker images and containers: Dockerfile; layers; build/run; .dockerignore Docker Compose: Services; PostgreSQL volumes; networks; startup CI/CD and hosting: GitHub Actions; test job; deployments; HTTPS basics Release operations: Secrets; backups; restore; logs; rollback
Learning outcomes
Explain linux and deployment foundations and distinguish correct use from a common misconception. Explain docker images and containers and distinguish correct use from a common misconception. Explain docker compose and distinguish correct use from a common misconception. Explain ci/cd and hosting and distinguish correct use from a common misconception. Explain release operations and distinguish correct use from a common misconception. Apply Linux and deployment foundations, Docker images and containers, Docker Compose to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the docker, deployment & ci/cd deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Linux and deployment foundations: Inspect local runtime and configs. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Docker images and containers: Containerize Django backend. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Docker Compose: Run app + PostgreSQL with Compose. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — CI/CD and hosting: Create CI pipeline and smoke test. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Release operations: Run a backup/recovery exercise. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Linux and deployment foundations: Write reproducible deployment steps for each project. Independent task 2 — Docker images and containers: Create container configurations for core portfolio services. Independent task 3 — Docker Compose: Launch Institute app and database reproducibly. Independent task 4 — CI/CD and hosting: Add automated checks and staging deploy to Job Portal. Independent task 5 — Release operations: Publish deployment URLs and release notes for portfolio applications.
23Advanced Backend & Performance7.5 hrs
Learn advanced backend & performance through structured practical training at IDM Technologies, Vallioor. Cover profiling and performance, caching with redis, background work and queues, and monitoring and resilience. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Profiling and performance: Measure first; latency; N+1; query profiling Caching with Redis: Cache-aside; expiry; invalidation; Redis basics Background work and queues: Celery basics; task states; retries; idempotency Monitoring and resilience: Structured logs; metrics; health checks; timeouts Performance assessment: Load-testing concepts; regression tests; tradeoffs
Learning outcomes
Explain profiling and performance and distinguish correct use from a common misconception. Explain caching with redis and distinguish correct use from a common misconception. Explain background work and queues and distinguish correct use from a common misconception. Explain monitoring and resilience and distinguish correct use from a common misconception. Explain performance assessment and distinguish correct use from a common misconception. Apply Profiling and performance, Caching with Redis, Background work and queues to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the advanced backend & performance deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Profiling and performance: Profile and improve a slow endpoint. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Caching with Redis: Cache a read-heavy Django endpoint. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Background work and queues: Queue a sample notification job. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Monitoring and resilience: Add health and error logging. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Performance assessment: Compare before/after measurements. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Profiling and performance: Measure API latency for jobs and admission listings. Independent task 2 — Caching with Redis: Cache course catalogue and public job filters. Independent task 3 — Background work and queues: Move booking confirmation notification to background job. Independent task 4 — Monitoring and resilience: Add service health/status metrics and incident notes. Independent task 5 — Performance assessment: Submit reproducible performance report across applications.
24Full Stack Capstone & Career Readiness7.5 hrs
Learn full stack capstone & career readiness through structured practical training at IDM Technologies, Vallioor. Cover portfolio release planning, feature completion, testing and stabilization, and production release and documentation. Build a working software feature or technical demonstration, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.
Topics and subtopics
Portfolio release planning: Requirements review; backlog; acceptance criteria; architecture Feature completion: Edge cases; responsive UI; backend rules; integration Testing and stabilization: Regression tests; role access; backups; bug triage Production release and documentation: Deployment; README; architecture diagrams; demo data Independent assessment and career presentation: Code explanation; live modification; interview Q&A; portfolio storytelling
Learning outcomes
Explain portfolio release planning and distinguish correct use from a common misconception. Explain feature completion and distinguish correct use from a common misconception. Explain testing and stabilization and distinguish correct use from a common misconception. Explain production release and documentation and distinguish correct use from a common misconception. Explain independent assessment and career presentation and distinguish correct use from a common misconception. Apply Portfolio release planning, Feature completion, Testing and stabilization to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the full stack capstone & career readiness deliverable against stated requirements, safety or quality criteria, and document corrections.
Practical activities
Workshop 1 — Portfolio release planning: Audit remaining work across three portfolios. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Feature completion: Finish a critical end-to-end workflow. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Testing and stabilization: Run end-to-end acceptance tests. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Production release and documentation: Deploy and verify the applications. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Independent assessment and career presentation: Demonstrate projects without AI code generation. Submit: source code, tests, setup notes and a short walkthrough. Independent task 1 — Portfolio release planning: Finalize release checklist and prioritized tasks for all three. Independent task 2 — Feature completion: Finish unfinished critical features with code review notes. Independent task 3 — Testing and stabilization: Resolve defects and finalize three project test reports. Independent task 4 — Production release and documentation: Publish live links, screenshots, architecture diagrams and README. Independent task 5 — Independent assessment and career presentation: Submit all three polished portfolio projects, retrospective and presentation.