INSTRUCTOR-LED · CLASSROOM TRAINING Expert · 180 Days

Java Full Stack — Expert Programme

Expert-level practical training in Java 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 Java 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 Java 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 Java 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 & Semantic Web12 hrs

Learn html5 & semantic web through structured practical training at IDM Technologies, Vallioor. Cover semantic html, forms, accessibility, and metadata. 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: Semantic HTML: key definitions and purpose; Semantic HTML: workflow and applied decisions in software development; Semantic HTML: demonstration, error review and independent verification Forms: forms: key definitions and purpose; forms: workflow and applied decisions in software development; forms: demonstration, error review and independent verification Accessibility: accessibility: keyboard and screen-reader behavior; accessibility: semantics, focus and contrast checks; accessibility: audit a representative flow and record findings Metadata: metadata: key definitions and purpose; metadata: workflow and applied decisions in software development; metadata: demonstration, error review and independent verification Page structure: page structure: key definitions and purpose; page structure: workflow and applied decisions in software development; page structure: demonstration, error review and independent verification

Learning outcomes

Explain semantic html and distinguish correct use from a common misconception. Explain forms and distinguish correct use from a common misconception. Explain accessibility and distinguish correct use from a common misconception. Explain metadata and distinguish correct use from a common misconception. Explain page structure and distinguish correct use from a common misconception. Apply Semantic HTML, Forms, Accessibility to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the html5 & semantic web deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Semantic HTML: produce a focused example applying semantic html to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Forms: produce a focused example applying forms to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Accessibility: produce a focused example applying accessibility to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Metadata: produce a focused example applying metadata to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Page structure: produce a focused example applying page structure to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Applied mini-project — HTML5 & Semantic Web: assemble a working software feature or technical demonstration combining Semantic HTML, Forms, Accessibility; document inputs, outputs and constraints. Review and peer demonstration — HTML5 & Semantic Web: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

03CSS3 & Responsive Layouts18 hrs

Learn css3 & responsive layouts through structured practical training at IDM Technologies, Vallioor. Cover selectors, box model, flexbox, and grid. 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

Selectors: Selectors: key definitions and purpose; Selectors: workflow and applied decisions in software development; Selectors: demonstration, error review and independent verification Box model: box model: inputs, assumptions and baseline selection; box model: evaluation, errors and leakage risks; box model: record a reproducible comparison experiment Flexbox: flexbox: key definitions and purpose; flexbox: workflow and applied decisions in software development; flexbox: demonstration, error review and independent verification Grid: grid: key definitions and purpose; grid: workflow and applied decisions in software development; grid: demonstration, error review and independent verification Responsive design: responsive design: brief, constraints and intended audience; responsive design: iteration, usability and review criteria; responsive design: produce and critique an annotated design artefact

Learning outcomes

Explain selectors and distinguish correct use from a common misconception. Explain box model and distinguish correct use from a common misconception. Explain flexbox and distinguish correct use from a common misconception. Explain grid and distinguish correct use from a common misconception. Explain responsive design and distinguish correct use from a common misconception. Apply Selectors, Box model, Flexbox to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the css3 & responsive layouts deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Selectors: produce a focused example applying selectors to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Box model: produce a focused example applying box model to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Flexbox: produce a focused example applying flexbox to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Grid: produce a focused example applying grid to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Responsive design: produce a focused example applying responsive design to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Applied mini-project — CSS3 & Responsive Layouts: assemble a working software feature or technical demonstration combining Selectors, Box model, Flexbox; document inputs, outputs and constraints. Review and peer demonstration — CSS3 & Responsive Layouts: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

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.

05Modern JavaScript & Async Programming20 hrs

Learn modern javascript & async programming through structured practical training at IDM Technologies, Vallioor. Cover es modules, dom, async/await, and fetch. 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

ES modules: ES modules: key definitions and purpose; ES modules: workflow and applied decisions in software development; ES modules: demonstration, error review and independent verification DOM: DOM: key definitions and purpose; DOM: workflow and applied decisions in software development; DOM: demonstration, error review and independent verification Async/await: async/await: key definitions and purpose; async/await: workflow and applied decisions in software development; async/await: demonstration, error review and independent verification Fetch: fetch: key definitions and purpose; fetch: workflow and applied decisions in software development; fetch: demonstration, error review and independent verification Error handling: error handling: key definitions and purpose; error handling: workflow and applied decisions in software development; error handling: demonstration, error review and independent verification

Learning outcomes

Explain es modules and distinguish correct use from a common misconception. Explain dom and distinguish correct use from a common misconception. Explain async/await and distinguish correct use from a common misconception. Explain fetch and distinguish correct use from a common misconception. Explain error handling and distinguish correct use from a common misconception. Apply ES modules, DOM, Async/await to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the modern javascript & async programming deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — ES modules: produce a focused example applying es modules to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — DOM: produce a focused example applying dom to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Async/await: produce a focused example applying async/await to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Fetch: produce a focused example applying fetch to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Error handling: produce a focused example applying error handling to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Applied mini-project — Modern JavaScript & Async Programming: assemble a working software feature or technical demonstration combining ES modules, DOM, Async/await; document inputs, outputs and constraints. Review and peer demonstration — Modern JavaScript & Async Programming: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

06Git, 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.

07Java Syntax & Program Flow22 hrs

Learn java syntax & program flow through structured practical training at IDM Technologies, Vallioor. Cover jdk, variables, control flow, and methods. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

JDK: JDK: key definitions and purpose; JDK: workflow and applied decisions in java development; JDK: demonstration, error review and independent verification Variables: variables: key definitions and purpose; variables: workflow and applied decisions in java development; variables: demonstration, error review and independent verification Control flow: control flow: key definitions and purpose; control flow: workflow and applied decisions in java development; control flow: demonstration, error review and independent verification Methods: methods: key definitions and purpose; methods: workflow and applied decisions in java development; methods: demonstration, error review and independent verification Arrays: arrays: key definitions and purpose; arrays: workflow and applied decisions in java development; arrays: demonstration, error review and independent verification

Learning outcomes

Explain jdk and distinguish correct use from a common misconception. Explain variables and distinguish correct use from a common misconception. Explain control flow and distinguish correct use from a common misconception. Explain methods and distinguish correct use from a common misconception. Explain arrays and distinguish correct use from a common misconception. Apply JDK, Variables, Control flow to create a runnable Java project or component with independently checkable evidence. Evaluate the java syntax & program flow deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — JDK: produce a focused example applying jdk to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Variables: produce a focused example applying variables to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Control flow: produce a focused example applying control flow to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Methods: produce a focused example applying methods to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 5 — Arrays: produce a focused example applying arrays to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Java Syntax & Program Flow: assemble a runnable Java project or component combining JDK, Variables, Control flow; document inputs, outputs and constraints. Review and peer demonstration — Java Syntax & Program Flow: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

08Object-Oriented Programming in Java24 hrs

Learn object-oriented programming in java through structured practical training at IDM Technologies, Vallioor. Cover classes, interfaces, inheritance, and polymorphism. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Classes: Classes: key definitions and purpose; Classes: workflow and applied decisions in java development; Classes: demonstration, error review and independent verification Interfaces: interfaces: key definitions and purpose; interfaces: workflow and applied decisions in java development; interfaces: demonstration, error review and independent verification Inheritance: inheritance: key definitions and purpose; inheritance: workflow and applied decisions in java development; inheritance: demonstration, error review and independent verification Polymorphism: polymorphism: key definitions and purpose; polymorphism: workflow and applied decisions in java development; polymorphism: demonstration, error review and independent verification

Learning outcomes

Explain classes and distinguish correct use from a common misconception. Explain interfaces and distinguish correct use from a common misconception. Explain inheritance and distinguish correct use from a common misconception. Explain polymorphism and distinguish correct use from a common misconception. Apply Classes, Interfaces, Inheritance to create a runnable Java project or component with independently checkable evidence. Evaluate the object-oriented programming in java deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Classes: produce a focused example applying classes to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Interfaces: produce a focused example applying interfaces to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Inheritance: produce a focused example applying inheritance to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Polymorphism: produce a focused example applying polymorphism to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Object-Oriented Programming in Java: assemble a runnable Java project or component combining Classes, Interfaces, Inheritance; document inputs, outputs and constraints. Review and peer demonstration — Object-Oriented Programming in Java: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

09Java Collections & Generics20 hrs

Learn java collections & generics through structured practical training at IDM Technologies, Vallioor. Cover lists, maps, sets, and generics. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Lists: Lists: key definitions and purpose; Lists: workflow and applied decisions in java development; Lists: demonstration, error review and independent verification Maps: maps: key definitions and purpose; maps: workflow and applied decisions in java development; maps: demonstration, error review and independent verification Sets: sets: key definitions and purpose; sets: workflow and applied decisions in java development; sets: demonstration, error review and independent verification Generics: generics: key definitions and purpose; generics: workflow and applied decisions in java development; generics: demonstration, error review and independent verification Iterators: iterators: key definitions and purpose; iterators: workflow and applied decisions in java development; iterators: demonstration, error review and independent verification

Learning outcomes

Explain lists and distinguish correct use from a common misconception. Explain maps and distinguish correct use from a common misconception. Explain sets and distinguish correct use from a common misconception. Explain generics and distinguish correct use from a common misconception. Explain iterators and distinguish correct use from a common misconception. Apply Lists, Maps, Sets to create a runnable Java project or component with independently checkable evidence. Evaluate the java collections & generics deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Lists: produce a focused example applying lists to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Maps: produce a focused example applying maps to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Sets: produce a focused example applying sets to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Generics: produce a focused example applying generics to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 5 — Iterators: produce a focused example applying iterators to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Java Collections & Generics: assemble a runnable Java project or component combining Lists, Maps, Sets; document inputs, outputs and constraints. Review and peer demonstration — Java Collections & Generics: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

10Exceptions, Files & Streams20 hrs

Learn exceptions, files & streams through structured practical training at IDM Technologies, Vallioor. Cover checked exceptions, file i/o, streams, and lambdas. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Checked exceptions: Checked exceptions: key definitions and purpose; Checked exceptions: workflow and applied decisions in java development; Checked exceptions: demonstration, error review and independent verification File I/O: file I/O: key definitions and purpose; file I/O: workflow and applied decisions in java development; file I/O: demonstration, error review and independent verification Streams: streams: key definitions and purpose; streams: workflow and applied decisions in java development; streams: demonstration, error review and independent verification Lambdas: lambdas: key definitions and purpose; lambdas: workflow and applied decisions in java development; lambdas: demonstration, error review and independent verification

Learning outcomes

Explain checked exceptions and distinguish correct use from a common misconception. Explain file i/o and distinguish correct use from a common misconception. Explain streams and distinguish correct use from a common misconception. Explain lambdas and distinguish correct use from a common misconception. Apply Checked exceptions, File I/O, Streams to create a runnable Java project or component with independently checkable evidence. Evaluate the exceptions, files & streams deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Checked exceptions: produce a focused example applying checked exceptions to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — File I/O: produce a focused example applying file i/o to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Streams: produce a focused example applying streams to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Lambdas: produce a focused example applying lambdas to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Exceptions, Files & Streams: assemble a runnable Java project or component combining Checked exceptions, File I/O, Streams; document inputs, outputs and constraints. Review and peer demonstration — Exceptions, Files & Streams: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

11Java Concurrency & JVM Basics18 hrs

Learn java concurrency & jvm basics through structured practical training at IDM Technologies, Vallioor. Cover threads, executors, synchronization, and memory basics. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Threads: Threads: key definitions and purpose; Threads: workflow and applied decisions in java development; Threads: demonstration, error review and independent verification Executors: executors: key definitions and purpose; executors: workflow and applied decisions in java development; executors: demonstration, error review and independent verification Synchronization: synchronization: key definitions and purpose; synchronization: workflow and applied decisions in java development; synchronization: demonstration, error review and independent verification Memory basics: memory basics: key definitions and purpose; memory basics: workflow and applied decisions in java development; memory basics: demonstration, error review and independent verification

Learning outcomes

Explain threads and distinguish correct use from a common misconception. Explain executors and distinguish correct use from a common misconception. Explain synchronization and distinguish correct use from a common misconception. Explain memory basics and distinguish correct use from a common misconception. Apply Threads, Executors, Synchronization to create a runnable Java project or component with independently checkable evidence. Evaluate the java concurrency & jvm basics deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Threads: produce a focused example applying threads to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Executors: produce a focused example applying executors to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Synchronization: produce a focused example applying synchronization to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Memory basics: produce a focused example applying memory basics to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Java Concurrency & JVM Basics: assemble a runnable Java project or component combining Threads, Executors, Synchronization; document inputs, outputs and constraints. Review and peer demonstration — Java Concurrency & JVM Basics: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

12SQL & Relational Database Foundations20 hrs

Learn sql & relational database foundations through structured practical training at IDM Technologies, Vallioor. Cover tables, relationships, joins, and grouping. Build a reproducible analysis workbook or query notebook, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Tables: Tables: key definitions and purpose; Tables: workflow and applied decisions in data analytics; Tables: demonstration, error review and independent verification Relationships: relationships: key definitions and purpose; relationships: workflow and applied decisions in data analytics; relationships: demonstration, error review and independent verification Joins: joins: join keys, cardinality and null handling; joins: inner, left and other join behavior; joins: verify row counts before and after a join Grouping: grouping: key definitions and purpose; grouping: workflow and applied decisions in data analytics; grouping: demonstration, error review and independent verification Constraints: constraints: key definitions and purpose; constraints: workflow and applied decisions in data analytics; constraints: demonstration, error review and independent verification

Learning outcomes

Explain tables and distinguish correct use from a common misconception. Explain relationships and distinguish correct use from a common misconception. Explain joins and distinguish correct use from a common misconception. Explain grouping and distinguish correct use from a common misconception. Explain constraints and distinguish correct use from a common misconception. Apply Tables, Relationships, Joins to create a reproducible analysis workbook or query notebook with independently checkable evidence. Evaluate the sql & relational database foundations deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Tables: produce a focused example applying tables to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: input dataset, transformation checks, chart or query results and interpretation. Workshop 2 — Relationships: produce a focused example applying relationships to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: input dataset, transformation checks, chart or query results and interpretation. Workshop 3 — Joins: produce a focused example applying joins to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: input dataset, transformation checks, chart or query results and interpretation. Workshop 4 — Grouping: produce a focused example applying grouping to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: input dataset, transformation checks, chart or query results and interpretation. Workshop 5 — Constraints: produce a focused example applying constraints to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: input dataset, transformation checks, chart or query results and interpretation. Applied mini-project — SQL & Relational Database Foundations: assemble a reproducible analysis workbook or query notebook combining Tables, Relationships, Joins; document inputs, outputs and constraints. Review and peer demonstration — SQL & Relational Database Foundations: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

13JDBC & Persistence Foundations16 hrs

Learn jdbc & persistence foundations through structured practical training at IDM Technologies, Vallioor. Cover prepared statements, transactions, datasource, and pooling. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Prepared statements: Prepared statements: key definitions and purpose; Prepared statements: workflow and applied decisions in java development; Prepared statements: demonstration, error review and independent verification Transactions: transactions: key definitions and purpose; transactions: workflow and applied decisions in java development; transactions: demonstration, error review and independent verification Datasource: datasource: key definitions and purpose; datasource: workflow and applied decisions in java development; datasource: demonstration, error review and independent verification Pooling: pooling: key definitions and purpose; pooling: workflow and applied decisions in java development; pooling: demonstration, error review and independent verification

Learning outcomes

Explain prepared statements and distinguish correct use from a common misconception. Explain transactions and distinguish correct use from a common misconception. Explain datasource and distinguish correct use from a common misconception. Explain pooling and distinguish correct use from a common misconception. Apply Prepared statements, Transactions, Datasource to create a runnable Java project or component with independently checkable evidence. Evaluate the jdbc & persistence foundations deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Prepared statements: produce a focused example applying prepared statements to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Transactions: produce a focused example applying transactions to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Datasource: produce a focused example applying datasource to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Pooling: produce a focused example applying pooling to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — JDBC & Persistence Foundations: assemble a runnable Java project or component combining Prepared statements, Transactions, Datasource; document inputs, outputs and constraints. Review and peer demonstration — JDBC & Persistence Foundations: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

14REST APIs & JSON12 hrs

Learn rest apis & json through structured practical training at IDM Technologies, Vallioor. Cover http, rest design, json, and status codes. 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

HTTP: HTTP: key definitions and purpose; HTTP: workflow and applied decisions in software development; HTTP: demonstration, error review and independent verification REST design: REST design: brief, constraints and intended audience; REST design: iteration, usability and review criteria; REST design: produce and critique an annotated design artefact JSON: JSON: key definitions and purpose; JSON: workflow and applied decisions in software development; JSON: demonstration, error review and independent verification Status codes: status codes: key definitions and purpose; status codes: workflow and applied decisions in software development; status codes: demonstration, error review and independent verification Authentication concepts: authentication concepts: identity, sessions or tokens; authentication concepts: authorization checks and common attack paths; authentication concepts: test allowed and forbidden account workflows

Learning outcomes

Explain http and distinguish correct use from a common misconception. Explain rest design and distinguish correct use from a common misconception. Explain json and distinguish correct use from a common misconception. Explain status codes and distinguish correct use from a common misconception. Explain authentication concepts and distinguish correct use from a common misconception. Apply HTTP, REST design, JSON to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the rest apis & json deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — HTTP: produce a focused example applying http to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — REST design: produce a focused example applying rest design to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — JSON: produce a focused example applying json to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Status codes: produce a focused example applying status codes to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Authentication concepts: produce a focused example applying authentication concepts to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Applied mini-project — REST APIs & JSON: assemble a working software feature or technical demonstration combining HTTP, REST design, JSON; document inputs, outputs and constraints. Review and peer demonstration — REST APIs & JSON: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

15Spring Core & Dependency Injection20 hrs

Learn spring core & dependency injection through structured practical training at IDM Technologies, Vallioor. Cover beans, configuration, di, and profiles. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Beans: Beans: key definitions and purpose; Beans: workflow and applied decisions in java development; Beans: demonstration, error review and independent verification Configuration: configuration: key definitions and purpose; configuration: workflow and applied decisions in java development; configuration: demonstration, error review and independent verification DI: DI: key definitions and purpose; DI: workflow and applied decisions in java development; DI: demonstration, error review and independent verification Profiles: profiles: key definitions and purpose; profiles: workflow and applied decisions in java development; profiles: demonstration, error review and independent verification

Learning outcomes

Explain beans and distinguish correct use from a common misconception. Explain configuration and distinguish correct use from a common misconception. Explain di and distinguish correct use from a common misconception. Explain profiles and distinguish correct use from a common misconception. Apply Beans, Configuration, DI to create a runnable Java project or component with independently checkable evidence. Evaluate the spring core & dependency injection deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Beans: produce a focused example applying beans to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Configuration: produce a focused example applying configuration to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — DI: produce a focused example applying di to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Profiles: produce a focused example applying profiles to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Spring Core & Dependency Injection: assemble a runnable Java project or component combining Beans, Configuration, DI; document inputs, outputs and constraints. Review and peer demonstration — Spring Core & Dependency Injection: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

16Spring Boot REST Development24 hrs

Learn spring boot rest development through structured practical training at IDM Technologies, Vallioor. Cover controllers, service layers, validation, and exception handling. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Controllers: Controllers: key definitions and purpose; Controllers: workflow and applied decisions in java development; Controllers: demonstration, error review and independent verification Service layers: service layers: key definitions and purpose; service layers: workflow and applied decisions in java development; service layers: demonstration, error review and independent verification Validation: validation: key definitions and purpose; validation: workflow and applied decisions in java development; validation: demonstration, error review and independent verification Exception handling: exception handling: key definitions and purpose; exception handling: workflow and applied decisions in java development; exception handling: demonstration, error review and independent verification

Learning outcomes

Explain controllers and distinguish correct use from a common misconception. Explain service layers and distinguish correct use from a common misconception. Explain validation and distinguish correct use from a common misconception. Explain exception handling and distinguish correct use from a common misconception. Apply Controllers, Service layers, Validation to create a runnable Java project or component with independently checkable evidence. Evaluate the spring boot rest development deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Controllers: produce a focused example applying controllers to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Service layers: produce a focused example applying service layers to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Validation: produce a focused example applying validation to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Exception handling: produce a focused example applying exception handling to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Spring Boot REST Development: assemble a runnable Java project or component combining Controllers, Service layers, Validation; document inputs, outputs and constraints. Review and peer demonstration — Spring Boot REST Development: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

17Spring Data JPA & Database Integration22 hrs

Learn spring data jpa & database integration through structured practical training at IDM Technologies, Vallioor. Cover entities, repositories, relations, and migrations. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Entities: Entities: key definitions and purpose; Entities: workflow and applied decisions in java development; Entities: demonstration, error review and independent verification Repositories: repositories: key definitions and purpose; repositories: workflow and applied decisions in java development; repositories: demonstration, error review and independent verification Relations: relations: key definitions and purpose; relations: workflow and applied decisions in java development; relations: demonstration, error review and independent verification Migrations: migrations: key definitions and purpose; migrations: workflow and applied decisions in java development; migrations: demonstration, error review and independent verification

Learning outcomes

Explain entities and distinguish correct use from a common misconception. Explain repositories and distinguish correct use from a common misconception. Explain relations and distinguish correct use from a common misconception. Explain migrations and distinguish correct use from a common misconception. Apply Entities, Repositories, Relations to create a runnable Java project or component with independently checkable evidence. Evaluate the spring data jpa & database integration deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Entities: produce a focused example applying entities to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Repositories: produce a focused example applying repositories to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Relations: produce a focused example applying relations to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Migrations: produce a focused example applying migrations to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Spring Data JPA & Database Integration: assemble a runnable Java project or component combining Entities, Repositories, Relations; document inputs, outputs and constraints. Review and peer demonstration — Spring Data JPA & Database Integration: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

18Spring Security & Authentication20 hrs

Learn spring security & authentication through structured practical training at IDM Technologies, Vallioor. Cover roles, jwt basics, session security, and authorization. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Roles: Roles: key definitions and purpose; Roles: workflow and applied decisions in java development; Roles: demonstration, error review and independent verification JWT basics: JWT basics: key definitions and purpose; JWT basics: workflow and applied decisions in java development; JWT basics: demonstration, error review and independent verification Session security: session security: least privilege and threat scenarios; session security: data protection and secure defaults; session security: review a feature for security failure paths Authorization: authorization: key definitions and purpose; authorization: workflow and applied decisions in java development; authorization: demonstration, error review and independent verification

Learning outcomes

Explain roles and distinguish correct use from a common misconception. Explain jwt basics and distinguish correct use from a common misconception. Explain session security and distinguish correct use from a common misconception. Explain authorization and distinguish correct use from a common misconception. Apply Roles, JWT basics, Session security to create a runnable Java project or component with independently checkable evidence. Evaluate the spring security & authentication deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Roles: produce a focused example applying roles to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — JWT basics: produce a focused example applying jwt basics to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Session security: produce a focused example applying session security to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Authorization: produce a focused example applying authorization to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Spring Security & Authentication: assemble a runnable Java project or component combining Roles, JWT basics, Session security; document inputs, outputs and constraints. Review and peer demonstration — Spring Security & Authentication: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

19Frontend Integration with Spring APIs18 hrs

Learn frontend integration with spring apis through structured practical training at IDM Technologies, Vallioor. Cover spa integration, forms, cors, and state and errors. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

SPA integration: SPA integration: key definitions and purpose; SPA integration: workflow and applied decisions in java development; SPA integration: demonstration, error review and independent verification Forms: forms: key definitions and purpose; forms: workflow and applied decisions in java development; forms: demonstration, error review and independent verification CORS: CORS: key definitions and purpose; CORS: workflow and applied decisions in java development; CORS: demonstration, error review and independent verification State and errors: state and errors: key definitions and purpose; state and errors: workflow and applied decisions in java development; state and errors: demonstration, error review and independent verification

Learning outcomes

Explain spa integration and distinguish correct use from a common misconception. Explain forms and distinguish correct use from a common misconception. Explain cors and distinguish correct use from a common misconception. Explain state and errors and distinguish correct use from a common misconception. Apply SPA integration, Forms, CORS to create a runnable Java project or component with independently checkable evidence. Evaluate the frontend integration with spring apis deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — SPA integration: produce a focused example applying spa integration to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Forms: produce a focused example applying forms to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — CORS: produce a focused example applying cors to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — State and errors: produce a focused example applying state and errors to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Frontend Integration with Spring APIs: assemble a runnable Java project or component combining SPA integration, Forms, CORS; document inputs, outputs and constraints. Review and peer demonstration — Frontend Integration with Spring APIs: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

20Automated Testing for Java18 hrs

Learn automated testing for java through structured practical training at IDM Technologies, Vallioor. Cover junit, mockito, integration tests, and testcontainers concepts. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

JUnit: JUnit: key definitions and purpose; JUnit: workflow and applied decisions in java development; JUnit: demonstration, error review and independent verification Mockito: Mockito: key definitions and purpose; Mockito: workflow and applied decisions in java development; Mockito: demonstration, error review and independent verification Integration tests: integration tests: key definitions and purpose; integration tests: workflow and applied decisions in java development; integration tests: demonstration, error review and independent verification Testcontainers concepts: testcontainers concepts: key definitions and purpose; testcontainers concepts: workflow and applied decisions in java development; testcontainers concepts: demonstration, error review and independent verification

Learning outcomes

Explain junit and distinguish correct use from a common misconception. Explain mockito and distinguish correct use from a common misconception. Explain integration tests and distinguish correct use from a common misconception. Explain testcontainers concepts and distinguish correct use from a common misconception. Apply JUnit, Mockito, Integration tests to create a runnable Java project or component with independently checkable evidence. Evaluate the automated testing for java deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — JUnit: produce a focused example applying junit to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Mockito: produce a focused example applying mockito to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Integration tests: produce a focused example applying integration tests to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Testcontainers concepts: produce a focused example applying testcontainers concepts to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Automated Testing for Java: assemble a runnable Java project or component combining JUnit, Mockito, Integration tests; document inputs, outputs and constraints. Review and peer demonstration — Automated Testing for Java: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

21Security, Privacy & Responsible Practice12 hrs

Learn security, privacy & responsible practice through structured practical training at IDM Technologies, Vallioor. Cover least privilege, secrets, privacy, and safe handling. 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

Least privilege: Least privilege: key definitions and purpose; Least privilege: workflow and applied decisions in software development; Least privilege: demonstration, error review and independent verification Secrets: secrets: key definitions and purpose; secrets: workflow and applied decisions in software development; secrets: demonstration, error review and independent verification Privacy: privacy: key definitions and purpose; privacy: workflow and applied decisions in software development; privacy: demonstration, error review and independent verification Safe handling: safe handling: key definitions and purpose; safe handling: workflow and applied decisions in software development; safe handling: demonstration, error review and independent verification Risk basics: risk basics: key definitions and purpose; risk basics: workflow and applied decisions in software development; risk basics: demonstration, error review and independent verification

Learning outcomes

Explain least privilege and distinguish correct use from a common misconception. Explain secrets and distinguish correct use from a common misconception. Explain privacy and distinguish correct use from a common misconception. Explain safe handling and distinguish correct use from a common misconception. Explain risk basics and distinguish correct use from a common misconception. Apply Least privilege, Secrets, Privacy to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the security, privacy & responsible practice deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Least privilege: produce a focused example applying least privilege to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Secrets: produce a focused example applying secrets to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Privacy: produce a focused example applying privacy to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Safe handling: produce a focused example applying safe handling to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Risk basics: produce a focused example applying risk basics to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Applied mini-project — Security, Privacy & Responsible Practice: assemble a working software feature or technical demonstration combining Least privilege, Secrets, Privacy; document inputs, outputs and constraints. Review and peer demonstration — Security, Privacy & Responsible Practice: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

22Spring Deployment & Observability18 hrs

Learn spring deployment & observability through structured practical training at IDM Technologies, Vallioor. Cover packaging, configuration, logs, and monitoring. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Packaging: Packaging: key definitions and purpose; Packaging: workflow and applied decisions in java development; Packaging: demonstration, error review and independent verification Configuration: configuration: key definitions and purpose; configuration: workflow and applied decisions in java development; configuration: demonstration, error review and independent verification Logs: logs: key definitions and purpose; logs: workflow and applied decisions in java development; logs: demonstration, error review and independent verification Monitoring: monitoring: key definitions and purpose; monitoring: workflow and applied decisions in java development; monitoring: demonstration, error review and independent verification CI/CD: CI/CD: key definitions and purpose; CI/CD: workflow and applied decisions in java development; CI/CD: demonstration, error review and independent verification

Learning outcomes

Explain packaging and distinguish correct use from a common misconception. Explain configuration and distinguish correct use from a common misconception. Explain logs and distinguish correct use from a common misconception. Explain monitoring and distinguish correct use from a common misconception. Explain ci/cd and distinguish correct use from a common misconception. Apply Packaging, Configuration, Logs to create a runnable Java project or component with independently checkable evidence. Evaluate the spring deployment & observability deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Packaging: produce a focused example applying packaging to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Configuration: produce a focused example applying configuration to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Logs: produce a focused example applying logs to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Monitoring: produce a focused example applying monitoring to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 5 — CI/CD: produce a focused example applying ci/cd to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Spring Deployment & Observability: assemble a runnable Java project or component combining Packaging, Configuration, Logs; document inputs, outputs and constraints. Review and peer demonstration — Spring Deployment & Observability: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

23Java Full Stack Capstone36 hrs

Learn java full stack capstone through structured practical training at IDM Technologies, Vallioor. Cover requirements, services, frontend, and tests. Build a runnable Java project or component, practise evidence-based review, and demonstrate job-relevant skills. This is a draft module outline, subject to trainer approval.

Topics and subtopics

Requirements: Requirements: key definitions and purpose; Requirements: workflow and applied decisions in java development; Requirements: demonstration, error review and independent verification Services: services: key definitions and purpose; services: workflow and applied decisions in java development; services: demonstration, error review and independent verification Frontend: frontend: key definitions and purpose; frontend: workflow and applied decisions in java development; frontend: demonstration, error review and independent verification Tests: tests: key definitions and purpose; tests: workflow and applied decisions in java development; tests: demonstration, error review and independent verification Deployment: deployment: environments, configuration and release steps; deployment: health checks, rollback and observability; deployment: document a safe staged release procedure

Learning outcomes

Explain requirements and distinguish correct use from a common misconception. Explain services and distinguish correct use from a common misconception. Explain frontend and distinguish correct use from a common misconception. Explain tests and distinguish correct use from a common misconception. Explain deployment and distinguish correct use from a common misconception. Apply Requirements, Services, Frontend to create a runnable Java project or component with independently checkable evidence. Evaluate the java full stack capstone deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Requirements: produce a focused example applying requirements to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 2 — Services: produce a focused example applying services to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 3 — Frontend: produce a focused example applying frontend to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 4 — Tests: produce a focused example applying tests to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Workshop 5 — Deployment: produce a focused example applying deployment to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup instructions and an execution trace. Applied mini-project — Java Full Stack Capstone: assemble a runnable Java project or component combining Requirements, Services, Frontend; document inputs, outputs and constraints. Review and peer demonstration — Java Full Stack Capstone: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.

24Project Planning, Documentation & Presentation12 hrs

Learn project planning, documentation & presentation through structured practical training at IDM Technologies, Vallioor. Cover requirements, milestones, documentation, and demo. 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

Requirements: Requirements: key definitions and purpose; Requirements: workflow and applied decisions in software development; Requirements: demonstration, error review and independent verification Milestones: milestones: key definitions and purpose; milestones: workflow and applied decisions in software development; milestones: demonstration, error review and independent verification Documentation: documentation: key definitions and purpose; documentation: workflow and applied decisions in software development; documentation: demonstration, error review and independent verification Demo: demo: key definitions and purpose; demo: workflow and applied decisions in software development; demo: demonstration, error review and independent verification Presentation: presentation: key definitions and purpose; presentation: workflow and applied decisions in software development; presentation: demonstration, error review and independent verification

Learning outcomes

Explain requirements and distinguish correct use from a common misconception. Explain milestones and distinguish correct use from a common misconception. Explain documentation and distinguish correct use from a common misconception. Explain demo and distinguish correct use from a common misconception. Explain presentation and distinguish correct use from a common misconception. Apply Requirements, Milestones, Documentation to create a working software feature or technical demonstration with independently checkable evidence. Evaluate the project planning, documentation & presentation deliverable against stated requirements, safety or quality criteria, and document corrections.

Practical activities

Workshop 1 — Requirements: produce a focused example applying requirements to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 2 — Milestones: produce a focused example applying milestones to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 3 — Documentation: produce a focused example applying documentation to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 4 — Demo: produce a focused example applying demo to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Workshop 5 — Presentation: produce a focused example applying presentation to a realistic brief; compare the initial result with a corrected result and record the reasoning. Submit: source code, tests, setup notes and a short walkthrough. Applied mini-project — Project Planning, Documentation & Presentation: assemble a working software feature or technical demonstration combining Requirements, Milestones, Documentation; document inputs, outputs and constraints. Review and peer demonstration — Project Planning, Documentation & Presentation: identify two likely mistakes, run a validation checklist, and explain improvements with evidence.