Front End React JS Course Syllabus

HTML

HTML Introduction

HTML Editors

Basic HTML Structure

HTML Elements and Attributes

HTML Headings

HTML Comments

HTML Styles

HTML Text Formatting

Colors in HTML

HTML Lists

Quotation and Citation Tags

CSS Linking Methods

Anchor Tag

Images in HTML

HTML Tables

Div and Span Elements

Block and Inline Elements

Iframe in HTML

Class and ID in HTML

HTML Favicon

File Paths in HTML

HTML Layouts

Embed Maps in HTML

HTML Special Characters

Emojis and Smileys in HTML

HTML Semantic Elements

HTML Forms

HTML Input Types

HTML textarea Element

HTML Form Select Element

HTML Radio Buttons and Checkboxes

HTML datalist Element

HTML label, fieldset, legend

SEO Tags in HTML

HTML Script Tag

HTML Viewport Meta Tag

HTML bdo Tag

HTML Validation

Canvas and SVG in HTML

Custom Data Attributes (data-*)

Audio and Video in HTML

Agile Methodology

Introduction to Agile

What is Agile?
History & evolution of Agile
The Agile Manifesto (values & principles)
Agile vs Traditional (Waterfall) approaches
Benefits & challenges of Agile

Agile Frameworks & Approaches

Scrum (most widely used)
Kanban
Extreme Programming (XP)
Crystal Method
Feature-Driven Development (FDD)
SAFe (Scaled Agile Framework)

Scrum Framework (Core Agile Practice)

Lean Software Development
Roles: Product Owner, Scrum Master, Development Team
Artifacts: Product Backlog, Sprint Backlog, Increment
Events: Sprint, Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective
Definition of Done (DoD)
User Stories & Story Points
Prioritization methods (MoSCoW, WSJF)

Agile Planning & Estimation

Release planning vs sprint planning
Estimation techniques (Planning Poker, T-shirt sizing, Fibonacci sequence)
Velocity & burndown charts

Agile Execution

Daily stand-ups (structure & best practices)
Task boards & Kanban boards
Managing WIP (Work in Progress)
Cross-functional teams & collaboration
Continuous integration & delivery in Agile

Agile Tools & Practices

Agile project management tools (Jira, Trello, Asana, Azure DevOps)
Tracking progress (Burndown, Burnup, Velocity charts)
Agile testing practices (Test-Driven Development, Behavior-Driven Development)
Pair programming & code reviews
Continuous feedback loops

Agile Metrics & Reporting

Measuring team performance (Velocity, Lead time, Cycle time)
Quality metrics (Defect density, Escaped defects)
Release metrics (Predictability, Customer satisfaction)
Using dashboards & reports effectively
LeSS (Large Scale Scrum)

Scaling Agile

Challenges in scaling Agile in large organizations
SAFe (Scaled Agile Framework)
Disciplined Agile Delivery (DAD)
Spotify model (Squads, Tribes, Chapters, Guilds)

Agile in Practice

Agile in distributed/remote teams
Hybrid Agile (Agile + Waterfall = “Water-Agile-Fall”)
Agile in non-software industries (marketing, HR, operations)
Common challenges & anti-patterns (micromanagement, lack of ownership, scope creep)

Agile Leadership & Culture

Servant leadership in Agile
Empowering self-organizing teams
Building trust & transparency
Handling conflict in Agile teams
Agile mindset & continuous improvement

Agile Testing & Quality Assurance

Test-Driven Development (TDD)
Behavior-Driven Development (BDD)
Continuous Testing in Agile pipelines
Role of QA in Agile teams
Automation in Agile environments

Agile Transformation & Adoption

Steps to adopt Agile in an organization
Organizational change management
Agile coaching & facilitation
Overcoming resistance to Agile
Measuring success of Agile adoption

Postman Tool

Introduction to APIs & Postman

What is Postman & why it’s used
Postman installation (Desktop & Web version)
Understanding APIs & HTTP methods (GET, POST, PUT, DELETE, PATCH)
Postman interface overview

Types of APIs

Creating a new request
Adding request URL & parameters
Setting request headers
Sending query parameters (?key=value)
Sending form data (form-data, x-www-form-urlencoded)
Sending raw JSON/XML requests

Client–Server Architecture

Understanding status codes (200, 201, 400, 401, 403, 404, 500)
Viewing response body (Pretty, Raw, Preview modes)
Inspecting headers & cookies
Downloading API response data

Introduction to Postman

Creating collections to group requests
Duplicating & organizing requests
Creating environments (dev, staging, production)
Using environment variables
Using global variables
Pre-request & test scripts for variables

Features and Use Cases of Postman

No Auth, Basic Auth, Bearer Token
API Key authentication
OAuth 1.0 & OAuth 2.0 authentication
JWT token authentication in Postman

System Requirements for Postman

Introduction to scripts in Postman
Setting variables dynamically before requests
Generating timestamps, random values, UUIDs
Using JavaScript in pre-request scripts

Downloading Postman

Writing basic tests (pm.test)
Validating status codes, response time, and body values
Using Chai assertion library in Postman tests
Checking response headers
Conditional tests (if/else logic)
Running multiple requests in sequence

Installing Postman

Using Collection Runner
Using data files (CSV, JSON) for data-driven testing
Iterations with different inputs

Postman Web vs Desktop App

Creating mock servers in Postman
Using mock server responses for testing
Simulating API responses without backend

Creating a Postman Account

Setting up monitors to run collections on schedule
Getting automated reports via email

Postman Interface Overview

Auto-generating documentation from Postman collections
Sharing API docs with team/public
Publishing documentation online

HTTP Protocol Fundamentals

Sharing collections & environments with team
Using Postman workspaces (Personal, Team, Public)
Version control with Postman

HTTP Methods (GET, POST, PUT, PATCH, DELETE)

Scripting with dynamic variables ({{$timestamp}}, {{$guid}})
Using Newman (Postman CLI) for automation
Integrating Postman with CI/CD pipelines (Jenkins, GitHub Actions)
Importing Swagger/OpenAPI specs into Postman
Using Postman with GraphQL APIs

HTTP Status Codes

REST API Principles

Creating Requests in Postman

Working with Query Parameters

Working with Headers in Postman

Request Body Types in Postman

Working with API Responses in Postman

Collections in Postman

Importing & Exporting Collections

Variables in Postman

Environments in Postman

Variable Scope & Priority in Postman

Authorization & Authentication

API Key Authentication

Bearer Token Authentication

Basic & OAuth 2.0 Authentication

Pre-request Scripts in Postman

Writing Test Scripts in Postman

Assertions & Validations in Postman

Postman Console & Debugging

Collection Runner

Data-Driven Testing in Postman

Newman Command Line Tool

Automating API Tests

Mock Servers in Postman

API Documentation Generation

API Monitoring with Postman

Workspaces & Collaboration in Postman

Version Control in Postman

GraphQL API Testing in Postman

SOAP API Testing

WebSocket API Testing

File Upload & Download Testing

Real-Time API Testing Projects

API Testing Best Practices

Security Considerations in API Testing

Rest API

Introduction to REST API

What is an API?
Types of APIs (REST, SOAP, GraphQL)
Principles of REST (Representational State Transfer)
HTTP Methods (GET, POST, PUT, PATCH, DELETE)
REST vs RESTful

REST API Basics

Resources and Endpoints
URI design best practices
HTTP Status Codes (200, 201, 400, 401, 404, 500, etc.)
Request and Response structure
Content types (JSON, XML)
Idempotency in REST APIs

Designing REST APIs

Resource modeling (nouns vs verbs)
Versioning strategies (v1, v2, headers, etc.)
Query parameters vs Path parameters
Pagination, Filtering, and Sorting

Authentication & Authorization

Basic Authentication
Token-based Authentication
API Keys
OAuth 2.0
JWT (JSON Web Tokens)
Role-based Access Control (RBAC)

Building REST APIs

REST API frameworks (Express.js, Django REST Framework, Laravel, Spring Boot, CodeIgniter 3/4)
Creating CRUD APIs
Handling file uploads
Middleware in REST APIs
Validating API requests

Advanced REST API Features

Rate limiting & throttling
Caching (ETag, Last-Modified, Redis)
HATEOAS (Hypermedia as the Engine of Application State)
API Gateway concepts
Webhooks (API-driven events)

Security in REST APIs

HTTPS and SSL/TLS
CORS (Cross-Origin Resource Sharing)
Input validation & sanitization
Preventing common attacks (SQL Injection, XSS, CSRF, Replay attacks)
Secure API keys & tokens management

Testing REST APIs

Manual Testing using Postman
Automating tests with Newman / PyTest / JUnit
Mocking APIs for development
Contract testing

Documentation & Best Practices

API Documentation (Swagger / OpenAPI)
API Blueprint / RAML
Writing developer-friendly docs
API versioning & deprecation strategy
Best practices for scalability and maintainability

Deployment & Monitoring

Hosting REST APIs (Cloud, On-prem, Docker)
API Logging & Monitoring (ELK, Prometheus, Grafana)
API Performance optimization
CI/CD for APIs
Error tracking (Sentry, Rollbar)

REST API vs Alternatives

Error handling and response format (Error codes, messages)
REST vs GraphQL
REST vs gRPC
REST vs SOAP
When to choose REST

JSON Web Tokens (JWT)

Introduction to JWT

What is JWT and why it’s used
Real-life use cases of JWT (e.g., authentication, API security)
Difference between JWT and traditional session-based authentication
Advantages & disadvantages of JWT

JWT Structure

Header (alg & typ)
Payload (claims)
Signature (how it’s created)
Understanding JWT format (xxxxx.yyyyy.zzzzz)

How JWT Works

Token creation process
Token sending in HTTP headers
Token verification process
JWT flow in authentication

JWT Algorithms

HMAC (HS256, HS384, HS512)
RSA (RS256, RS384, RS512)
ECDSA (ES256, ES384, ES512)
Symmetric vs Asymmetric signing

Creating JWT

Libraries for different languages PHP: firebase/php-jwt, JavaScript: jsonwebtoken, Python: PyJWT, Java: jjwt
Encoding & decoding tokens

Using JWT for Authentication

Login process with JWT
Storing JWT (localStorage, sessionStorage, cookies)
Sending JWT in Authorization: Bearer header
Protecting API routes with JWT middleware

Refresh Tokens

Why access tokens should be short-lived
Refresh token mechanism
Secure storage of refresh tokens
Rotating refresh tokens

Security Best Practices

Using HTTPS
Keeping the secret key safe
Token expiration (exp) and validation
Preventing JWT replay attacks
Avoid storing sensitive data in the payload (since it’s not encrypted)
Blacklisting tokens after logout

Advanced JWT Topics

Stateless authentication at scale
Using JWT with OAuth 2.0
Multi-device login handling with JWT
JWT with Role-Based Access Control (RBAC)
Revoking JWTs
Using JWK (JSON Web Key) and JWKS endpoint

JWT Debugging & Testing

Using jwt.io for decoding and debugging
Common JWT errors and fixes
Testing JWT-protected APIs with Postman

Git & Git Hub

Introduction to Version Control

What is Version Control?
Benefits of Git over other VCS (e.g., SVN)
Centralized vs Distributed VCS
Git vs GitHub (and GitLab, Bitbucket)

Installing & Git Basics

Configuring Git
Initializing a repo: git init
Checking status: git status
Adding files: git add
Committing changes: git commit -m
Viewing commit history: git log
Ignoring files with .gitignore

Working with GitHub

Creating a GitHub account
Creating a repository on GitHub
Connecting local repo to GitHub
Cloning a repository: git clone
Pulling updates: git pull

Branching and Merging

What are branches?
Creating branches: git branch feature-x
Switching branches: git checkout
Creating & switching: git checkout -b feature-x
Merging branches: git merge
Resolving merge conflicts

Git Workflow Models

git checkout vs git restore
git reset (soft, mixed, hard)
git revert
Viewing diffs: git diff

Undoing Changes

Forking repositories
Pull requests (PRs)
Reviewing PRs
Merging PRs

Collaborating on GitHub

Using Issues and Discussions
Assigning reviewers and labels

Working with Remotes

Listing remotes: git remote -v
Adding/removing remotes
Pushing to multiple remotes
Tracking branches

Tags and Releases

Creating tags: git tag v1.0
Annotated vs lightweight tags
Pushing tags to GitHub: git push origin v1.0
GitHub Releases tab

Git Tools and Advanced Features

GUI Tools & Integrations

Git Introduction

Git Install

Git Config

Git Get Started

Git – New Files

Git Staging Area

Git Commit

Git Tagging

Git Stash

Git History

Git Help

Git Branch

Git Merge

Git Workflow

Git Best Practices

Git Glossary

GitHub Get Started

Git: What is SSH?

GitHub Add SSH

GitHub Set Remote

GitHub Edit Code

Pull from GitHub

Push to GitHub

GitHub Branch

Pull Branch from GitHub

Push Branch to GitHub

GitHub Flow

GitHub Pages

Git GUI Clients

GitHub Fork

Git Clone from GitHub

GitHub Send Pull Request

Git Revert

Git Reset

Git Commit Amend

Git Rebase

Git Reflog

Git Recovery

Git .gitignore

Git .gitattributes

Git Large File Storage

Git Signing Commits & Tags

Git Cherrypick & Patch

Git Merge Conflicts

Git CI/CD

Git Hooks

Git Submodules

Git Remote Advanced

Bootstrap

Bootstrap Basics

What is Bootstrap?
File Structure and Bootstrap Workflow
Bootstrap Containers (.container, .container-fluid)

Setting Up Bootstrap

CDN Method
Local Installation
Using with Package Managers (NPM/Yarn)

Grid System

Rows and Columns
Breakpoints (xs, sm, md, lg, xl, xxl)
Responsive Columns and Nesting
Offset and Order Classes

Typography and Utilities

Headings, Paragraphs, and Display Text
Text Alignment and Transformation
Lists and Inline Text Elements
Borders and Shadows

Utility Classes

Spacing (margin, padding)
Colors (text, background
Sizing and Visibility
Display Utilities (d-flex, d-none, etc.)

Bootstrap Components

Buttons , Cards, Alerts, Badges
Breadcrumbs, Pagination, Progress Bars, List Groups
Jumbotron (Deprecated in v5) ,Toasts, Accordions ,Collapse
Carousel (Image Slider) ,Modals , Popovers and Tooltips , Spinners

Forms and Inputs

Form Controls (text, checkbox, radio, select, file)
Floating Labels
Input Groups (add-ons, prepend/append)
Validation States
Form Layouts (inline, horizontal, grid-based)

Navigation and Layout

Navbar (responsive menus, dropdowns, toggler)
Navs and Tabs
Sidebar (custom)
Scrollspy
Vertical and Horizontal Alignments
Media Object

Responsive Design & Advanced Grid

Responsive Utilities
Responsive Images (.img-fluid)
Flexbox Utilities (d-flex, justify-content, align-items)
Grid Customization
Gutters and No-Gutters
Position Utilities (relative, absolute, fixed, etc.)

Advanced Bootstrap

Theming with Sass Variables (Bootstrap 5+)
Customizing Bootstrap (override default styles)
Bootstrap Icons
Using JavaScript Plugins (without jQuery in Bootstrap 5)
Bootstrap with jQuery (for legacy versions)
Accessibility (ARIA roles, focus management)
Integrating Bootstrap with other frameworks (React, Laravel, etc.)

Redux

Redux Fundamentals

What is Redux and Why Use It?
Core Principles of Redux : Single Source of Truth, State is Read-Only , Pure Functions
Redux vs Context API
Redux Architecture (Store, Actions, Reducers)

Basic Redux Setup

Installing Redux and React-Redux
Creating a Redux Store
Actions and Action Creators
Reducers (Pure Functions)
Using Redux DevTools

Modern Redux with Redux Toolkit

Introduction to Redux Toolkit (RTK)
configureStore()
createSlice() - Reducers + Actions
Using useSelector() and useDispatch()
Redux Toolkit Best Practices

Async Actions and Middleware

What is Middleware?
Using Redux Thunk for Async Logic
Writing Async Thunks with createAsyncThunk
Loading and Error States

Advanced Redux Patterns

Normalizing State Shape
Memoization and Reselect
Combining Multiple Reducers
Middleware Customization
Redux Logger Middleware
Debugging Redux with Tools and Logs

Testing Redux

Testing Reducers
Testing Action Creators
Testing Async Thunks
Testing React Components with Redux State

Redux Toolkit Query (RTK Query)

What is RTK Query?
API Slice with createApi()
Fetching and Mutating Data
Automatic Caching and Re-fetching
RTK Query with Authentication Headers
Error Handling and Loading States in RTK Query

React JS

React Fundamentals

React Overview & Features

React vs Traditional DOM

Setting Up Environment

React Folder Structure & Entry Point

Rendering Elements in React

Virtual DOM & Reconciliation

React.StrictMode and Warnings

Unmounting Components

JSX (JavaScript XML)

JSX Syntax & Rules

Embedding Expressions in JSX

JSX Attributes & className

JSX Nesting & Parent Wrapping Rules

Conditional Rendering in React

React Fragments

JSX Styling

Escaping and Sanitization in React JSX

React Components

Component Definition

Component Composition

Default and Named Exports

Props and Props Validation

Default Props in React

Children (props.children)

State in Function Components

State in Class Components

Controlled vs Uncontrolled Components

Re-render Triggers

React Component Lifecycle

Pure Components and React.PureComponent

Props & State Deep Dive

Passing Data with Props

Destructuring Props in React

State Initialization in React

Updating State Safely

Derived State

Lifting State Up in React

State Immutability in React

React 18 State Batching

React Event Handling

Handling Events in React

Synthetic Events in React

Passing Arguments to Event Handlers

PreventDefault & StopPropagation

Inline vs Handler Functions

Conditional Rendering

If-Else Rendering

Short-circuit Rendering

React Ternary Operator

Return Null Pattern in React

Conditional Components

React Lists & Keys

Rendering Lists with map()

Using Keys in React

Index as Key

Dynamic Lists and Filtering

Forms Handling in React

Controlled Components in React

Uncontrolled Components with useRef

Handling Input, Textarea & Select in React

Checkbox and Radio Buttons in React

Multiple Input Fields

Form Submission in React

Validation Basics

Reset & Clear Functions in React Forms

Styling in React

Inline CSS in React

External CSS Files in React

CSS Modules

Conditional Class Names

CSS Variables

Dynamic Styles with State

React Hooks

Introduction & Rules of React Hooks

React useState() Hook

useEffect() Hook

useContext() Hook

React useRef() Hook

useReducer()

useCallback()

React useMemo() Hook

React useLayoutEffect() Hook

useImperativeHandle() Hook

Custom Hooks in React

Hook Dependency Arrays

React Context API

Creating Context

Context: Provider & Consumer

useContext() Hook

React Context Default Values

Nested Contexts

Avoiding Prop Drilling

Advanced React Concepts

React Portals

React Fragments

Error Boundaries

Higher-Order Components

Render Props Pattern

Forwarding Refs in React

Refs & DOM Manipulation

Controlled vs Uncontrolled Inputs

React Memoization

React Strict Mode

React Keys & Re-renders

React Router

React Router — Installation & Setup

BrowserRouter, Routes & Route

React Router: Link, NavLink & Active Links

useNavigate, useLocation & useParams

Nested Routes

Route Parameters

404 – Not Found Routes

React Router Redirects

Protected Routes

Lazy Loading Routes

React Suspense & Lazy Loading

React.lazy()

Suspense and Fallback

Suspense for Data Fetching

Loading States and Fallback UI

Performance Optimization

Rendering Performance Concepts

React.memo()

useMemo() and useCallback()

Avoiding Unnecessary Re-renders

Virtualization Concepts

React Profiler Tool

React 18+ Features

Automatic Batching

Concurrent Rendering

Transitions (useTransition)

Deferred Values (useDeferredValue)

Suspense for Data

Streaming Server Rendering

React Miscellaneous & Utilities

React StrictMode

Default Exports vs Named Exports

Hydration & Client Rendering

createRoot() vs render()

Unmounting Components

React DevTools Usage

Accessibility (ARIA Roles in React)

Internationalization Basics

jQuery

Introduction to jQuery

What is jQuery?
Why use jQuery?
jQuery CDN vs Local file
jQuery Syntax Overview ($(selector).action())

jQuery — Features & Advantages

Basic selectors (*, #id, .class, element)
Hierarchy selectors (div p, ul > li)
Attribute selectors (input[type="text"])
Filter selectors (:first, :last, :eq(), :odd, :even)

jQuery Installation

click(), dblclick()
hover(), mouseenter(), mouseleave()
focus(), blur()
keydown(), keyup(), keypress()
submit(), change(), resize(), scroll()
on() method (recommended for dynamic elements)

Understanding jQuery Syntax

show(), hide(), toggle()
fadeIn(), fadeOut(), fadeToggle()
slideDown(), slideUp(), slideToggle()
animate() method (custom animations)
stop() method

jQuery Document Ready

html(), text(), val()
attr(), prop()
addClass(), removeClass(), toggleClass(), hasClass()
css() – Get/Set CSS styles
append(), prepend(), after(), before()
remove(), empty()

jQuery Selectors

parent(), parents(), children()
next(), prev(), siblings()
find(), filter(), eq(), first(), last(), not()

jQuery Element Selectors

Getting/setting input values
Validating form fields using jQuery
Showing validation error messages dynamically
Disabling/enabling buttons and inputs

jQuery ID & Class Selectors

What are jQuery plugins?
How to include and use a plugin
Examples: Datepicker, Lightbox, Slick slider

jQuery Attribute Selectors

$.ajax()
$.get(), $.post()
Loading external data without page refresh
Handling JSON data
Success and error callbacks

jQuery Form Selectors

Parse and stringify JSON
Display JSON data in HTML
Using jQuery with APIs

jQuery Events

Difference between on() and direct binding
Handling dynamically created elements

jQuery Mouse Events

Using data-* attributes with .data()

jQuery Keyboard Events

What is a deferred object?
Chaining asynchronous actions

jQuery Form Events

Minimize DOM access
Cache selectors
Use .on() instead of repeated bindings
Unbind unused events

jQuery Window Events

try...catch with jQuery
Handling AJAX errors gracefully

jQuery on() & off()

Using jQuery with Bootstrap (Modals, Dropdowns)
Integrating jQuery with backend (PHP, CodeIgniter, Laravel, etc.)
jQuery vs JavaScript: When to use what

jQuery Event Delegation

jQuery Event Object

jQuery preventDefault() & stopPropagation()

jQuery Hide & Show

jQuery Fade Effects Tutorial

jQuery Slide Effects Tutorial

jQuery Animate Tutorial

jQuery stop() Tutorial

jQuery delay() Method

jQuery Queue

jQuery Callback Tutorial

jQuery Chaining Tutorial

jQuery HTML Tutorial

jQuery Get Methods

jQuery Set Methods

jQuery Add Elements

jQuery Remove Elements

jQuery css() Method

jQuery CSS Class Methods

jQuery Dimensions

jQuery Traversing

jQuery Traversing – Ancestors

jQuery Traversing - Descendants

jQuery Traversing – Siblings

jQuery Traversing – Filtering

jQuery each() Method

jQuery .data() Method

jQuery noConflict()

jQuery Utility Methods

jQuery Form Handling

jQuery serialize()

jQuery Form Validation

jQuery AJAX

jQuery .load() Method

jQuery $.get() and $.post() Methods

jQuery AJAX Core

jQuery AJAX Setup

jQuery AJAX with JSON

jQuery AJAX Events

jQuery Plugins

jQuery Create Plugin

jQuery Performance Tips

Advance JavaScript

JavaScript Arrow Functions

JavaScript Classes

JavaScript Prototypes

JavaScript Inheritance

JavaScript Symbols

JavaScript Iterables

JavaScript Set Methods

JavaScript Maps and Map Methods

JavaScript Iterators & Generators

JavaScript Destructuring

JavaScript Spread & Rest Operator

JavaScript Optional Chaining

JavaScript Nullish Coalescing

JavaScript Template Literals

JavaScript Callbacks

JavaScript Async

JavaScript Promises

JavaScript Async / Await

JavaScript Event Loop

JavaScript Debounce & Throttle

JavaScript Error Handling: try, catch, finally

JavaScript Closures

JavaScript Modules

JavaScript Modules: Import & Export

JavaScript Strict vs Sloppy Mode

JavaScript Fetch API

JavaScript AJAX

JavaScript Storage: localStorage & sessionStorage

JavaScript Geolocation

JavaScript Web Workers

JavaScript Service Workers

JavaScript Performance Optimization

JavaScript DOM innerHTML

JavaScript DOM Forms

JavaScript DOM CSS

JavaScript DOM Animations

JavaScript DOM Events

JavaScript DOM Event Listeners

JavaScript DOM Navigation

JavaScript DOM Collections

JavaScript DOM NodeLists

JavaScript DOM Nodes

JavaScript Browser BOM

JavaScript Window Object

JavaScript Screen Object

JavaScript Location, History, Navigator & Popups

JavaScript Timing (setTimeout & setInterval)

JavaScript Cookies

JavaScript Regular Expressions

JavaScript Operator Precedence

JavaScript Errors

JavaScript Memory Management

JavaScript

JavaScript Introduction

JavaScript – Where to Place Your Code

JavaScript Output

JavaScript Syntax

JavaScript Statements

JavaScript Comments

JavaScript Variables

JavaScript let, var, and const

JavaScript Operators

JavaScript Assignment Operators

JavaScript Comparison & Logical Operators

JavaScript Data Types

JavaScript Booleans

JavaScript typeof Operator

JavaScript toString() Method

JavaScript Type Conversion

JavaScript if, else if, and switch Statements

JavaScript Loops

JavaScript Break and Continue Statements

JavaScript Functions

JavaScript Scope

JavaScript Hoisting

JavaScript Strict Mode

JavaScript this Keyword

JavaScript Objects

JavaScript Objects: Properties, Methods, Display, Constructors

JavaScript Strings

JavaScript Numbers & BigInt

JavaScript Arrays

JavaScript Dates

JavaScript Math Object

JavaScript DOM Introduction

JavaScript DOM Methods

JavaScript DOM Document

JavaScript DOM Elements

CSS

Introduction to CSS

CSS Syntax

CSS Selectors

CSS Linking Methods

CSS Comments

CSS Colors

CSS Background Color

CSS Background Image

CSS Background Repeat

CSS Background Attachment

CSS Background Position

CSS Borders

CSS Margins

CSS Padding

CSS Height and Width

CSS Box Model

CSS Outline

CSS Text Properties

CSS Fonts

CSS Icons

CSS Links

CSS Lists

CSS Table Layout

CSS display Property

CSS Max Width

CSS position Property

CSS Z-Index

CSS Overflow

CSS Float

CSS Display: inline-block

CSS Combinators

CSS Pseudo-classes

CSS Pseudo-elements

CSS Opacity

CSS Navbar

CSS Dropdown Menus

CSS Image Gallery

CSS Image Sprites with Hover Navigation

CSS Attribute Selectors

CSS Forms

CSS Counters

CSS Layout

CSS Units

CSS Specificity

CSS !important Rule

CSS Math Functions

CSS Border Images

CSS Background Properties

CSS Current Keywords

CSS Gradients: Linear, Radial & Conic

CSS Text & Box Shadows

CSS Text Effects

CSS Web Fonts & @font-face Rule

CSS 2D & 3D Transformations

CSS Transitions

CSS Animations

CSS Tooltip

CSS Image Styling

CSS Image Centering

CSS Image Filters

CSS Image Shapes

CSS object-fit

CSS object-position

CSS Image Masking

CSS Buttons

CSS Pagination

CSS Multiple Columns

CSS User Interface

CSS Variables

CSS @property

CSS box-sizing

CSS @media Queries

CSS Flexbox

Full CSS Grid Layout Tutorial

JIRA Ticket System

Introduction to JIRA

What is JIRA?
History & evolution (Atlassian tools)
JIRA as issue tracking vs project management tool
Use cases: Agile projects, IT service management, bug tracking, DevOps
JIRA Core vs JIRA Software vs JIRA Service Management

Getting Started with JIRA

JIRA account setup (Cloud vs Server)
JIRA dashboard overview
Navigation: menus, search, filters
Understanding issues, projects, and boards
JIRA terminology (Epics, Stories, Tasks, Bugs, Sub-tasks)

Projects in JIRA

Creating a new project
Project templates (Kanban, Scrum, Bug Tracking, Service Desk)
Configuring project settings
Project roles & permissions
Project categories and schemes

Issues & Tickets

Creating issues/tickets (bug, story, task)
Issue fields (summary, description, priority, assignee, reporter, status, labels)
Linking issues (blocks, relates to, duplicates)
Adding comments & attachments
Issue watchers & followers

JIRA Workflows

What is a workflow?
Default workflow vs custom workflow
Workflow states & transitions
Conditions, validators, post-functions
Workflow schemes & mapping to projects

Boards & Agile in JIRA

Kanban boards (columns, WIP limits)
Scrum boards (sprints, backlog, active sprint)
Creating & managing sprints
Burndown & velocity charts
Swimlanes & quick filters

Searching & Filters

Basic search (using fields & dropdowns)
Advanced search using JQL (JIRA Query Language)
Common JQL queries (by project, assignee, status, priority, date)
Saving & sharing filters
Subscriptions to filters

Reports & Dashboards

JIRA reports (Burndown, Sprint report, Epic report, Velocity)
Project progress reports
Custom dashboards with gadgets
Sharing dashboards with teams
Monitoring team performance with metrics

User & Permission Management

Adding & managing users
Groups & roles
Project permissions vs global permissions
Security schemes (restricting issue visibility)
Audit logs & activity tracking

JIRA Administration

Global settings & configurations
Issue type schemes
Field configurations & screen schemes
Notification schemes (email alerts, Slack integration)
Automation rules (auto-assign, auto-close, status transitions)

Integrations

JIRA with Confluence (documentation)
JIRA with Bitbucket/GitHub (code integration)
JIRA with CI/CD tools (Jenkins, Bamboo, GitLab CI)
Slack/MS Teams integration for updates
REST APIs for JIRA automation

Service Management

JIRA Service Desk overview
Customer portals & SLAs
Queues & ticket categorization
Automating support workflows
Knowledge base integration