JAVA Full Stack Engineering Course

1. What is the internet.
2. How does the web work.
3. The role of HTML and CSS.
4. Setting up a development environment. (code editor, browser)
5. HTML Basics.
6. Structure of an HTML document.

1. Text formatting. (headings, paragraphs, emphasis)
2. Lists. (ordered and unordered)
3. Links. (anchors)
4. Image.

1. Creating input fields. (text, number, email, etc.)
2. Buttons. (submit, reset)
3. Labels.
4. Form validation.

1. Introduction to CSS.
2. Selectors. (element, class, ID)
3. Properties and values.
4. Styling text. (font, color, size)
5. Styling elements. (background, border, margin, padding)

1. Block, inline, and inline-block elements.
2. Float and clear properties.
3. CSS Grid.
4. Advanced CSS Topics.

1. Positioning. (relative, absolute, fixed)
2. Units of measurement. (pixels, percentages, ems, rems)
3. Color theory and color models.
4. Media queries for responsive design.

1. Plan and design a basic website. (e.g., a personal portfolio or a score
board)
2. Implement the HTML structure.
3.Apply CSS styles for layout and appearance.
4. Test and debug the website.

1. What is JavaScript.
2. Why is it called JavaScript.
3. What can in-browser JavaScript do.
4. JavaScript and VS Code.
5. Code structure.

1. Variables: (let, var, const).
2. Data Types:
Number.
String.
Boolean.
Null.
Undefined.
Objects.
3. Type of Operator.
Mathematical Operators & their precedence.
Comparison Operators.
Logical Operators.

1. If statement.
2. If...else statement. (including ternary operator)
3. Else if ladder.
4. Switch case.

1. While loop.
2. Do...while loop.
3. For loop.

1. Functions:
Function Declaration.
Local variables.
Outer variables.
Parameters.
Default values.
Returning a value.
Naming a function.  
2. Objects: the basics.

1. Objects: continued.
2. Strings: properties and methods.

1. Arrays: creation, access, manipulation.
2. Array functions: map, filter, reduce, etc.

1. Classes.
2. Constructors.
3. Getters and setters.
4. Inheritance.

1. Querying and selecting elements.
2. Traversing elements.
3. Creating elements.
4. Updating elements.
5. Removing elements.

1. Event listeners.
2. OnClick event.
3. Mouse events.
4. Keyboard events.

1. What is a Database.
2. Define a Database and its Components. (tables, records, fields)
3. Explain the role of a DBMS. (Database Management System)
4. Introduction to SQL.
SQL as a language for interacting with databases.
Basic SQL syntax and structure.
Common SQL commands. (SELECT, FROM, WHERE, ORDER BY)
5. Data types in SQL
Numeric. (INT, DECIMAL, FLOAT)
Character. (CHAR, VARCHAR)
Date and Time. (DATE, TIME, DATETIME)
Boolean. (BIT)
6. Creating tables
Using the CREATE TABLE statement.
Defining columns, data types, and constraints (PRIMARY KEY,
FOREIGN KEY, NOT NULL).

1. Inserting data.
Using the INSERT INTO statement.
Handling NULL values.
2. Updating data
Using the UPDATE statement.
Updating multiple rows.
3. Deleting data
Using the DELETE statement.
Deleting rows based on conditions.
4. Filtering data
Using the WHERE clause with comparison operators (=, <, >, <=,
>=, !=)
Using logical operators. (AND, OR, NOT)
Combining conditions.

1. Sorting data
Using the ORDER BY clause to sort results.
Ascending and descending order.
2. Grouping data
Using the GROUP BY clause to group rows.
Aggregate functions. (COUNT, SUM, AVG, MIN, MAX)

1. Indexes
Creating indexes to improve query performance.
Types of indexes. (clustered, non-clustered)
2. Performance tuning
Identifying performance bottlenecks.
Query optimization techniques. (explain plans, query rewriting)
3. Stored procedures
Creating and executing stored procedures.
Passing parameters.
Returning results.
4. Functions
Creating and using functions.
Scalar functions and table-valued functions.

1. Transactions.
Defining transactions.
Committing and rolling back transactions.
2. ACID properties.
Atomicity, consistency, isolation, durability.
3. Database design principles.
4. Entity-relationship (ER) diagrams.
5. Normalization. (1NF, 2NF, 3NF)
6. Normalization techniques.
7. Identifying functional dependencies.
8. Eliminating anomalies.

1. Database security.
User accounts and permissions.
Encryption.
Auditing.
2. Database backup.
Creating backups.
Restoring databases.

1. Practice exercises.
2. Applying SQL concepts to real-world scenarios.
3. Troubleshooting common SQL errors.
4. Question and answer Class.
5. Addressing learners' questions and concerns.

1. Overview of Java and its Features.
2. JVM, JRE, and JDK.
3. Basic Java Program Structure.
4. Keywords and Identifiers.
5. Data Types and Variables.
6. Type Casting.

1. Defining and Calling Methods.
2. Method Overloading.
3. Pass-by-Value in Java.
4. Recursion in Java.
5. Understanding main() Method.
6. Access Modifiers with Methods.

1. Introduction to Strings and String Class.
2. String Methods. (length(), char At(), substring(), etc.)
3. String Concatenation.
4. String Immutability and String Buffer/String Builder.
6. String Comparison. (equals(), compare To())
7. String Manipulation Examples.

1. Overview of JVM and its Importance.
2. Components: Class Loader, Heap, Method Area, Stack.
3. Class Loading Process. (Loading, Linking, Initialization)
4. Execution Engine. (Interpreter and JIT Compiler)
5. Basics of Garbage Collection.

1. Primitive and Non-Primitive Data Types.
2. Variable Declaration, Initialization, and Scope.
3. Default Values of Variables.
4. Type Casting. (Implicit and Explicit)

1. Introduction to Arrays. (Single and Multi-Dimensional)
2. Declaring, Initializing, and Accessing Arrays.
3. Common Operations: Traversal, Searching, Sorting.
4. Arrays vs Array List. (Basic Differences)

1. Introduction to Exceptions and Their Importance.
2. Try, Catch, and Finally Blocks.
3. Types of Exceptions: Checked and Unchecked.
4. Throw and Throws Keywords.
5. Basics of Custom Exceptions.

1. Overview of Collections Framework.
2. List Interface: Array List and Linked List.
3. Set Interface: Hash Set and Tree Set.
4. Introduction to Map. (Hash Map Basics)
5. Iterators for Traversing Collections.

1. Understanding Threads and Multithreading.
2. Thread Lifecycle and States.
3. Creating Threads. (Extending Thread Class, Implementing Runnable)
4. Synchronization Basics.
5. Deadlock Concept.

1. Introduction to Java I/O Streams.
2. Byte and Character Streams.
3. File Handling Basics. (Reading and Writing Files)
4. Buffered Streams Overview.

1. Overview of Lambda Expressions.
2. Functional Interfaces and Their Usage.
3. Basics of Stream API.
4. Common Operations: filter, map, and reduce.
5. Parallel Streams Introduction.

1. What is the Java?
2. Why use ?
3. Installing Visual Studio.
4. Creating a new Console App project
output & comments.

1. Variables.
2. Constants.
3. Data types.
4. Type casting.
5. Operators.
Arithmetic operators.

1. Operators continued.
Assignment Operators.
Comparison Operators.
Logical Operators.
Control structures.
2. if statement.
3. if...else statement.
4. if...else ladder.
5. Switch case.

1. Loops.
2. While loop.
3. Do...while loop.
4. For loop.
5. Break and continue statements.

1. Arrays
2. 2D arrays
3. For each loop

1. Methods/functions.
2. Creating a method.
3. Calling a method.
4. Parameters and arguments.
5. Default parameter values.
6. Return values.
7. Named arguments.
8. Method overloading.

1. What is OOPs?
2. Classes and members.
3. Constructors.
4. Constructor parameters.

1. Access modifiers.
2. Encapsulation.
3. Properties.
4. Inheritance.

1. Polymorphism.
2. Abstraction.
3. Interfaces.

1. Exceptions: try...catch, throw.
2. Generics: introduction, generic classes.
3. Generic collections.
4. List.
5. Dictionary.
6. Sorted List.
7. Queue.
8. Stack.

1. Files and directories.
2. Streams.
3. Creating, opening, writing to, and reading from files
4. Serialization.
5. Object to binary file stream.
6. Object to XML file stream.
7. Object to JSON string.

1. Basic operations (access, insertion, deletion).
2. Time and space complexity analysis.
3. Array-based implementations of stacks and queues.

1. Singly, doubly, and circular linked lists.
2. Traversal, insertion, deletion operations.
3. Time and space complexity analysis.

1. LIFO and FIFO principles.
2. Array and linked list implementations.
3. Applications (e.g., expression evaluation, backtracking).

1. Binary trees, binary search trees, heaps.
2. Tree traversals (preorder, inorder, postorder).
3. Insertion, deletion, and search operations.
4. Heap operations (insertion, deletion, heapify).

1. Linear search, binary search.
2. Bubble sort, insertion sort, selection sort, merge sort, quick sort.
3. Time and space complexity analysis.

1. Hash functions, collision handling techniques (separate chaining,
open addressing).
2. Applications (e.g., dictionaries, sets).

1. Graph representations (adjacency matrix, adjacency list).
2. Graph traversal algorithms.
3. Minimum spanning trees.
4. Shortest path algorithms.

1. Introduction to dynamic programming.
2. Solving problems using memorization and tabulation.
3. Classic DP problems (e.g., Fibonacci, knapsack, longest common
subsequence).

1. Overview of JDBC and Its Role in Database Connectivity.
2. JDBC Architecture and Components.
3. Types of JDBC Drivers. (Type-1 to Type-4)
4. Key Interfaces: Driver Manager, Connection, Statement, Result Set.

1. Steps to Configure and Set Up JDBC in a Project.
2. Loading the Driver Class. (Class for Name)
3. Establishing a Database Connection Using Driver Manager.
4. Basic Error Handling with SQL Exception.

1. Writing SQL Queries in Java.
2. Using Statement for Query Execution.
3. Performing CRUD Operations: Insert, Update, Delete, Select.
4. Closing Resources: Connection, Statement, and Result Set.

1. Overview of Statement, Prepared Statement, and Call able
Statement.
2. Advantages of Prepared Statement. (Preventing SQL Injection)
3. Using Call able Statement for Stored Procedures.
4. Differences Between the Statement Types.

1. Understanding Transactions in JDBC.
2. Using set Auto Commit, commit, and rollback.
3. Batch Processing in JDBC.
4. Working with Stored Procedures.

1. What is Hibernate?
2. Importance of ORM. (Object-Relational Mapping)
3. Features of Hibernate.
4. Hibernate Architecture.
5. Installing and Setting up Hibernate.

1. Hibernate Configuration File. (hibernate.cfg.xml)
2. Mapping File. (.hbm.xml)
3. Annotations in Hibernate.
4. Hibernate Session Factory and Session.

1. Saving data to the database. (Session. save())
2. Retrieving data from the database. (Session. get() and Session. load())
3. Updating and Deleting records.
4. Transactions in Hibernate.

1. One-to-One Mapping.
2. One-to-Many and Many-to-One Mapping.
3. Many-to-Many Mapping.

1. Introduction to HQL.
2. Writing basic queries. (SELECT, UPDATE, DELETE)
3. Joins in HQL.
4. Criteria API.

1. Caching in Hibernate. (First-level and Second-level Cache)
2. Batch Processing.
3. Native SQL in Hibernate.
4. Inheritance Mapping.

1. Integrating Hibernate with Spring Framework.
2. Testing Hibernate Applications.
3. Best Practices in Hibernate.

1. What is web browser?
2. What is web resources?
3. Types of web resources.
4. What is web server?
5. Installing of apache tomcat web server.

1. Servlet introduction.
2. Creating the first servlet in web app.
3. Steps to create WAR file.
4. Build & Deployment process.

1. About servlet containers & its advantages.
2. Request and response objects.
3. GetParameter() and getParameters() methods.
4. About XML.
5. About deployment descriptor(web.xml).

1. Generic servlet.
2. HTTP Servlet.
3. Difference between Generic servlet and HTTP Servlet.
4. Servlet life cycle.
5. Single thread model servlets.
6. Servlet context and servlet config.
7. Redirect, Forward and Include.

1. How to create JSP.
2. Difference between Servlet and JSP.
3. JSP Scripting Elements.
4. Scriptlet tag.
5. Expression tag.
6. Declaration tag.

1. Request object.
2. Response object.
3. Config object.
4. Application object.
5. Session object.
6. Exception handling in JSP.
7. About isErrorPage and errorPage.

1. Why Spring.
2. Spring modulus
3. Spring application
4. Spring in eclipse

1. IOC container.
2. Dependency injection.
3. Constructor injection.
4. Constructor injection dependent object.
5. Constructor injection with collection.
6. Constructor injection with collection 2.
7. Constructor injection with map.
8. Constructor injection in inheritance been.
9. Setter injection.
10. Setter injection dependent object.
11. Setter injection with collection.
12. Setter injection with collection 2.
13. Setter injection with map.
14. Injection with map 2.
15. Constructor injection versus setter injection
16. Auto wiring.
17. Factory method.

1. MVC introduction.
2. Multiple view pages.
3. Multiple controllers.
4. Model interface.
5. Request Param annotation.
6. Form tag library.
7. Form text field.
8. Form radio field.
9. Form checkbox.
10. Form drop-down list.

1. Setting up the development environment.
2. Creating a new ASP.NET Core Web API project.
3. Understanding the project structure.
4. Building a basic REST API endpoint.
5. HTTP methods (GET, POST, PUT, DELETE).
6. JSON serialization and deserialization.

1. Implementing CRUD operations (Create, Read, Update, Delete).
2. Handling HTTP status codes.
3. Error handling and exception management.
4. Data validation and input sanitization.
5. Authentication and authorization (basic authentication, JWT).
6. Versioning REST APIs.

1. Using HttpClient to make HTTP requests.
2. De-serializing JSON responses.
3. Asynchronous programming and task-based asynchronous pattern (TAP).
4. Consuming third-party APIs.

1. What is React? Why use React?
2. React vs. other frameworks (Vue, Angular).
3. Setting up React using create-react-app.
4. Overview of the folder structure.
5. Running the first React app (npm start).
6. Introduction to JSX.

1. What are React components? Functional vs. Class components.
2. Creating a functional component.
3. Understanding JSX and embedding expressions.
4. Component properties (props).
5. Nesting and reusing components.

1. What is state? Difference between state and props.
2. Using the useState hook for functional components.
3. Handling state updates.
4. Conditional rendering based on state.
5. Introduction to lifecycle methods (for awareness).

1. Handling events in React (onClick, onChange, etc.).
2. Passing arguments to event handlers.
3. Handling form submission.
4. Understanding synthetic events.

1. Using conditional rendering (if-else, ternary operators).
2. Rendering lists using map.
3. Using keys in lists.
4. Dynamic list rendering and managing state.

1. Introduction to React Router.
2. Setting up routes.
3. Navigation using Link and NavLink.
4. Passing parameters to routes.
5. Handling 404 pages.

1. Inline styling.
2. CSS stylesheets.
3. CSS Modules.
4. Styled-components (optional).
5. Best practices for styling React apps.

1. Using fetch and axios for GET requests
2. Using useEffect for data fetching.
3. Handling loading and error states.
4. Displaying fetched data in components.

1. Creating and submitting data using POST requests.
2. Updating data with PUT requests.
3. Deleting data with DELETE requests.
4. Handling API responses and errors.

1. What is Redux? Why use it?
2. Setting up Redux in a React app.
3. Creating actions, reducers, and the Redux store.
4. Connecting Redux to React components with use Dispatch and
use Selector.

1. Introduction to Redux Thunk for async actions.
2. Dispatching actions in asynchronous code.
3. Handling API calls with Redux.
4. Best practices for managing async actions.

1. Authentication concepts (login, logout, user roles).
2. Handling user sessions using tokens (JWT).
3. Protecting routes using Private Route components.
4. Storing authentication state in Redux.

1. Implementing role-based access (admin vs. user).
2. Using local Storage to persist user sessions.
3. Logout functionality and session expiration.
4. Handling authentication errors.

1. Preparing the app for deployment (building the app).
2. Deploying to vercel.
3. Handling environment variables for deployment.

1. What is version control?
2. Why is it important?
3. What is Git?
4. What is GitHub?
5. Setting up Git and creating a GitHub account.
6. Version control terminology.
Repository
Branch
Master
Stage
Commit
Clone
Push
Pull
Fetch
VS Code Integration

1. Staging and Committing Changes.
2. Repository Management Commands.
3. Branching and Merging.
4. Viewing and Comparing Changes.
5. Adding a Remote Repository.

1. Working on an Existing Repository.
2. Undoing Changes.

1. Design and implement a user-friendly interface using modern web
technologies.

1. Build efficient database schemas using SQL or NoSQL databases.

1. Develop RESTful APIs for seamless frontend-backend
communication.

1. Master version control and collaboration using Git.

1. Deploy your application to the Azure cloud for scalability and security.

1. What is Cloud Computing?
2. Types of Clouds.
3. Cloud Computing Models – SaaS / PaaS / IaaS.
4. Data Centres and Availability Zones.
5. Overview of a Cloud Platform (Microsoft Azure).
6. Exploring Various Cloud Resources.

1. What is DevOps?
2. Azure DevOps Walkthrough.

1. Continuous Integration.
2. Continuous Deployment.

1. AI and its Applications.
2. Machine Learning Concepts.
3. Difference Between Machine Learning and AI.

1. Generative AI, LLM, and Prompt Engineering.
2. Natural Language Processing.
3. AI-Based Hands-on Project.

1. Learn how to handle real-world interview scenarios thru practice sessions with tech leads and hiring managers from top-tier organizations.

2. Meet & Greet: Learn how to effectively greet the interviewers and establish the first impression.

3. How to Present Yourself: Learn how to present yourself professionally, including mastering body language, attire, and clear communication to make a strong first impression.

1. We will train you to answer complex technical questions confidently, emphasizing problem-solving and practical knowledge application.

2. Behavioral Questions: Learn how to respond to behavioral questions using the STAR method, showcasing your interpersonal skills, teamwork, and ability to handle workplace challenges.

1. Power Dressing.
2. Strong Communication.
3. Time Management.
4. Leadership Quality.