Full Stack Developer PHP 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

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

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

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

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.)

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

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

PHP

PHP Introduction

PHP Installing XAMPP Server

PHP Code Structure

PHP Echo & Print Statement

PHP Comments

PHP Variables

PHP Data Types

PHP Constant Variables

PHP Arithmetic Operators

PHP Assignment Operators

PHP Comparison Operators

PHP Logical Operators

PHP If Statement

PHP If Else Statement

PHP If Elseif Statement

PHP Switch Statement

PHP Ternary Operator

PHP String Operators

PHP Continue & Break Statement

PHP Goto Statement

PHP While Loop

PHP Do While Loop

PHP For Loop

PHP Nested Loop

PHP Functions

PHP Arrays

PHP Associative Array

PHP Foreach Loop

PHP Multidimensional Array

PHP Multidimensional Associative Array

PHP Foreach Loop with list()

PHP Array Count & Sizeof Function

PHP array_pop() & array_push()

PHP array_shift() & array_unshift()

PHP Array_Merge & Array_Combine

PHP array_slice() Function

PHP array_splice() Function

PHP Array Sorting Functions

PHP Array Traversing Functions

PHP Array list() Function

PHP Array extract() & compact()

PHP array_range() Function

PHP explode() & implode()

PHP str_split() & chunk_split()

PHP String LowerCase & UpperCase Functions

PHP String Length & Count Functions

PHP String Search & Find Position Functions

PHP String Search Functions

PHP substr() Function

PHP String Replace Functions

PHP String Compare Functions

PHP strrev() & str_shuffle()

PHP str_pad() & str_repeat()

PHP String Trim & Chop Functions

PHP Date Function

PHP time()

PHP mktime() & gmmktime()

PHP date_create() & date_format()

PHP checkdate() & date_diff()

PHP Include and Require Statement

PHP include_once & require_once

PHP $_GET, $_POST, $_REQUEST Variables

PHP $_SERVER Variable

PHP $_COOKIE Variable

PHP Session Variables

PHP $_FILES & move_uploaded_file()

PHP die() & exit()

MySQL Introduction

MySQL Installation and Workbench

MySQL CREATE TABLE

MySQL INSERT Statement

MySQL INSERT Multiple Rows

MySQL SELECT With WHERE Clause

MySQL AND, OR, NOT Operators

MySQL IN Operator

MySQL BETWEEN & NOT BETWEEN Operator

MySQL LIKE Operator & Wildcards

MySQL ORDER BY & DISTINCT

MySQL IS NULL & IS NOT NULL

MySQL LIMIT & OFFSET

MySQL UPDATE Statement

MySQL DELETE

Advance PHP

PHP Function Arguments By Reference

PHP Variable Functions

PHP Function with Returning Value

PHP Function with Default Parameters

PHP in_array() & array_search()

PHP array_replace & array_replace_recursive

PHP Array Key Functions

PHP Array Intersect Functions

PHP Array Diff & Udiff Functions

PHP Array_Values & Array_Unique

PHP Array Column & Chunk Functions

PHP Array_Flip & Array_Change_Key_Case

PHP array_sum() & array_product()

PHP Array_Fill & Array_Fill_Keys

PHP array_walk() & array_walk_recursive()

PHP array_map() Function

PHP array_reduce()

PHP array_rand() & shuffle()

PHP addslashes() & stripslashes()

PHP htmlentities() & htmlspecialchars()

PHP MD5 & SHA1 Functions

PHP convert_uuencode() & convert_uudecode()

PHP bin2hex() & hex2bin()

PHP chr() & ord() Functions

PHP strip_tags() & wordwrap()

PHP Math min() & max()

Math Functions — Ceil, Floor, Round & Abs

PHP Math: intdiv(), sqrt(), pow()

PHP rand(), mt_rand() & lcg_value()

PHP Date_add, Date_sub & Date_modify

PHP Getdate, Localtime & Gettimeofday

PHP date_parse() Function

PHP Strtotime, Strftime & Gmstrftime

PHP date_time_set() Function

PHP TimeZone Functions

MySQL Constraints

MySQL PRIMARY KEY and FOREIGN KEY

MySQL INNER JOIN

MySQL LEFT JOIN & RIGHT JOIN

MySQL CROSS JOIN

MySQL JOIN Multiple Tables

MySQL GROUP BY & HAVING Clause

MySQL SubQuery with EXISTS & NOT EXISTS

MySQL UNION and UNION ALL

MySQL IF and CASE Statement

MySQL Arithmetic Functions

MySQL String Functions

MySQL Date Functions

MySQL Time Functions

MySQL VIEW

MySQL INDEX

MySQL ALTER Statement

MySQL DROP & TRUNCATE Table

MySQL Regular Expression

MySQL COUNT, SUM, MIN, MAX, AVG

MySQL COMMIT & ROLLBACK

PHP MySQL CRUD – Read Data

PHP MySQL CRUD – Create Data

PHP MySQL CRUD – Update Data

PHP MySQL CRUD – Delete Data

PHP MySQLi Fetch Functions

PHP MySQLi Affected Rows

PHP MySQLi Error Functions

PHP MySQLi Object Oriented

PHP MySQLi Prepare Function

PHP CRUD Class

PHP CRUD Class – Insert Method

PHP CRUD Class – Update Method

PHP CRUD Class – Delete Method

PHP CRUD Class – Select Method

PHP CRUD Class Pagination Method

PHP CRUD Class – Usage Example

PHP AJAX Introduction

PHP AJAX Insert Records in Database

PHP AJAX Delete Records From Database

PHP AJAX Update Records

PHP AJAX Live Search

PHP AJAX Pagination

PHP AJAX Load More Pagination

PHP AJAX Serialize Form Data

PHP AJAX – $_GET & $_POST Methods

JSON Introduction

PHP json_encode() Function

PHP json_decode() Function

PHP Create Dynamic JSON File

Read JSON Data with jQuery

PHP REST API Introduction

PHP REST API – Read Data

PHP REST API – Create & Update Data

PHP REST API – Delete & Search Data

PHP REST API in Web Page

PHP Coronavirus API

PHP OOP Introduction

PHP OOP Constructor Function

PHP OOP Inheritance

PHP OOP Access Modifiers

PHP OOP Overriding Properties & Methods

PHP OOP Abstract Class

PHP OOP Interfaces

PHP OOP Static Members

PHP OOP Late Static Binding

PHP OOP Traits

PHP OOP Traits Method Overriding

PHP OOP Type Hinting

PHP OOP Namespace

PHP OOP Method Chaining

PHP OOP Magic Methods

PHP Magic Constants

PHP OOP Conditional Functions

PHP OOP Getter Method

PHP OOP Set Method

PHP OOP Call Method (__call)

PHP OOP __callStatic() Method

PHP OOP __isset() Magic Method

PHP OOP __unset() Magic Method

PHP OOP __toString() Method

PHP OOP __sleep() Method

PHP OOP __wakeup() Method

PHP OOP Clone Method

PHP OOP __invoke() Method

PHP OOP Autoload Method

PHP Is Conditional Functions

PHP Filter Validations

PHP Sanitize Filter

PHP filter_var_array()

PHP filter_input() Function

Password Hashing

Preventing SQL Injection & XSS

PHP FileSystem Functions

PHP FileSystem is_* Functions

PHP Chmod & Fileperms Functions

PHP file_put_contents() & file_get_contents()

PHP glob() Function

PHP getcwd(), chdir(), scandir()

PHP opendir(), readdir(), closedir()

PHP Regular Expressions Tutorial

PHP preg_replace() & preg_split()

PHP – How to Send Email

PHP MySQL PDO

PHP MySQL PDO – Prepare Method

PHP PDO – Advanced Fetch Styles

PHP PDO with Exception Handling

PHP PDO – Transactions

PHP PDO – bindColumn Method

PHP MySQL Read Data with JS Fetch Method

PHP MySQL Insert Data with Fetch API

PHP MySQL Update Data with JS Fetch

PHP MySQL Delete Data with JS Fetch

PHP MySQL Search Data with Fetch API

PHP Exception Handling

PHP Exception Handling — Try, Catch, Finally

PHP Custom Exception Classes

PHP Exception Handling – Throwing Exceptions

PHP Exception Handling – Exception Logging

PHP Exception Handling – Multiple Exceptions

PHP Exception Handling – Errors & Exceptions Together

MySQL

Classification of SQL Commands

What is MySQL?
Installing MySQL (XAMPP, WAMP, standalone)
MySQL Workbench / phpMyAdmin
Database vs Table
SQL Syntax and Statement Types
Data Types (INT, VARCHAR, TEXT, DATE, FLOAT, etc.)
Creating and Dropping Databases
Creating, Altering, and Dropping Tables

MySQL Introduction

SELECT – Retrieving Data
INSERT – Adding Records
UPDATE – Modifying Records
DELETE – Removing Records
WHERE Clause
ORDER BY, LIMIT
DISTINCT
BETWEEN, IN, LIKE, IS NULL

MySQL RDBMS Concepts

Primary Key
Foreign Key

Installing MySQL with XAMPP

INNER JOIN
LEFT JOIN
RIGHT JOIN
FULL OUTER JOIN (with workaround)
Self Join
Cross Join

MySQL SQL — Overview

Aggregate Functions (COUNT, SUM, AVG, MIN, MAX)
String Functions (CONCAT, LENGTH, UPPER, LOWER)
Date and Time Functions (NOW, CURDATE, DATEDIFF)
Numeric Functions (ROUND, CEIL, FLOOR)

MySQL Data Types

GROUP BY Clause
HAVING Clause
Subqueries (Single-row and Multi-row)
Nested Queries

MySQL Database

Importing and Exporting Data (CSV, SQL)
Backup and Restore
AUTO_INCREMENT
DEFAULT Values
ENUM and SET Data Types
Temporary Tables

MySQL CREATE DATABASE

Indexes (Single and Composite)
EXPLAIN Keyword (Query Optimization)
Views – Creating and Using
Triggers
Stored Procedures and Functions
Events and Schedulers

MySQL DROP DATABASE

MySQL User Management
Creating Users
Granting and Revoking Privileges
Role-Based Access Control (RBAC)
SQL Injection and Prevention

MySQL CREATE and DROP TABLE

Transactions (START TRANSACTION, COMMIT, ROLLBACK)
ACID Properties
LOCKs (Explicit and Implicit)
Normalization (1NF, 2NF, 3NF, BCNF)
Denormalization
Cursors
Partitioning Tables
Foreign Key Constraints with ON DELETE / ON UPDATE

MySQL ALTER TABLE

MySQL Constraints

MySQL NOT NULL Constraint

MySQL UNIQUE Constraint

MySQL PRIMARY KEY

MySQL FOREIGN KEY

MySQL CHECK Constraint

MySQL DEFAULT Constraint

MySQL AUTO_INCREMENT

MySQL CREATE INDEX

MySQL Table Relationships

MySQL INSERT INTO

MySQL SELECT

MySQL WHERE Clause

MySQL AND, OR, NOT

MySQL UPDATE

MySQL DELETE

MySQL NULL Values

MySQL LIMIT

MySQL ORDER BY

MySQL Aliases

MySQL LIKE

MySQL Wildcards

MySQL IN

MySQL BETWEEN

MySQL EXISTS

MySQL — ANY & ALL

MySQL CASE

MySQL COUNT() Function

MySQL AVG() Function

MySQL SUM() Function

MySQL MIN() Function

MySQL MAX() Function

MySQL GROUP BY

MySQL HAVING

MySQL JOINS

MySQL INNER JOIN

MySQL LEFT JOIN

MySQL RIGHT JOIN

MySQL CROSS JOIN

MySQL SELF JOIN

MySQL UNION

MySQL UNION ALL

MySQL Subqueries

Correlated Subqueries

MySQL CTE

MySQL Temporary Tables

MySQL INSERT INTO SELECT

MySQL Copy Table

MySQL GROUP_CONCAT() Function

MySQL Transactions

MySQL START TRANSACTION

MySQL COMMIT

MySQL ROLLBACK

MySQL SAVEPOINT

MySQL Stored Functions

MySQL Isolation Levels

MySQL VARCHAR, ENUM & SET

MySQL Views

MySQL Updatable Views

MySQL Indexing Strategies

MySQL EXPLAIN Plan

Slow Query Optimization

MySQL String Functions

MySQL Numeric Functions

MySQL Date Functions

MySQL Advanced Functions

MySQL JSON Data Type

JSON Functions

MySQL JSON Indexing

MySQL CREATE USER

GRANT Permissions in MySQL

MySQL REVOKE Permissions

MySQL Roles & Privileges

MySQL Database Backup

Restore Database in MySQL

MySQL mysqldump Tool

MySQL Stored Procedures

MySQL Cursor

MySQL User Defined Functions

MySQL Triggers

MySQL Event Scheduler

MySQL Window Functions

MySQL DECIMAL, CAST & CONVERT

OOP's

OOP Basics

What is Object-Oriented Programming?
Procedural vs OOP Approach
Classes and Objects
Attributes (Properties/Fields)
Methods (Functions inside classes)
Object Instantiation
__init__ / Constructors
self / this Keyword

Core Principles of OOP (Pillars)

Encapsulation
Abstraction
Inheritance
Polymorphism

Advanced Class Concepts

Class vs Object vs Instance
Class Variables vs Instance Variables
Static Methods and Variables
final / sealed Classes and Methods
Abstract vs Interface vs Concrete Classes
Inner/ Nested Classes
Anonymous Classes
Destructors / __del__ (language-dependent)

OOP Patterns and Architectures

Composition vs Inheritance
Dependency Injection
Association, Aggregation, Composition
UML Class Diagrams
Object Lifecycle and Garbage Collection

Language-Specific OOP Features

Python OOP (dunder methods, metaclasses)
Java OOP (interfaces, abstract classes, access modifiers)
C++ OOP (virtual functions, friend classes, pointers to objects)
PHP OOP (traits, namespaces, late static binding)
JavaScript OOP (prototypes, ES6 classes)

PHP - Codeigniter

PHP - Laravel

PHPUnit

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

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

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

Docker Hub

Introduction to Docker Hub

What is Docker Hub
Difference between Docker & Docker Hub
Public vs Private repositories
Docker Hub vs other container registries (GitHub Container Registry, AWS ECR, GCP Artifact Registry)

Setting up Docker Hub

Creating a Docker Hub account
Understanding Docker Hub dashboard
Linking Docker Hub with Docker CLI (docker login)

Docker Hub Repositories

Public repositories (free access)
Private repositories (restricted access)
Creating a new repository
Repository naming conventions (username/repo-name)

Working with Docker Images

Understanding Docker images & tags
Pulling images from Docker Hub (docker pull)
Pushing images to Docker Hub (docker push)
Tagging images (docker tag)
Updating images in Docker Hub

Searching & Using Images

Searching for images on Docker Hub (docker search)
Official vs community images
Checking image details, tags & pull count
Reading image documentation

Image Versioning

Using latest tag (:latest) vs version tags (:1.0, :1.1)
Best practices for tagging images
Maintaining multiple versions of the same image

Automated Builds

Connecting Docker Hub with GitHub/GitLab
Setting up automated builds from source code
Build triggers on commit
Using build hooks

Organizations & Teams

Creating an organization in Docker Hub
Adding team members & setting permissions
Managing access control for repositories

Docker Hub Webhooks

Setting up webhooks for automation
Triggering CI/CD pipelines after image push
Real-time deployment updates

Security in Docker Hub

Understanding image vulnerabilities
Using Docker Hub’s image scanning
Removing sensitive data from images
Limiting public exposure of private images

Rate Limits & Usage

Docker Hub pull rate limits (free vs pro plans)
Checking your rate limit status
Optimizing image pulls to avoid limits

Best Practices

Using .dockerignore to reduce image size
Keeping images small & efficient
Cleaning up unused images & tags
Proper image naming & tagging strategy

Advanced Topics

Multi-architecture images (ARM, x86)
Using Docker Content Trust (DCT) for signing images
Replicating images to other registries
Caching strategies for faster builds

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

Redis Data Structure Server

Introduction to Redis

What is Redis?
Key features & use cases
Redis architecture & in-memory model
Installing & setting up Redis (Linux, Windows, Docker)
Redis CLI basics

Redis Data Types (Core Structures)

Strings
Lists
Sets
Hashes
Sorted Sets (ZSETs)

Advanced Data Structures

Bitmaps (tracking active users, unique visits)
HyperLogLog (approximate cardinality/counting)
Streams (event logs, real-time data pipelines)
Geospatial data (locations, distance queries)

Key Management

Key naming conventions & best practices
EXPIRE & TTL (time-to-live)
PERSIST & key eviction policies
Redis persistence: RDB snapshots & AOF logs

Transactions & Scripting

MULTI, EXEC, DISCARD, WATCH
Optimistic locking with WATCH
Lua scripting in Redis
Use cases of scripts (atomic operations)

Pub/Sub Messaging

PUBLISH & SUBSCRIBE basics
Channels & message broadcasting
Real-time notifications with Redis Pub/Sub
Limitations & when to use Redis Streams instead

Redis as a Cache

Caching strategies (write-through, write-behind, cache-aside)
Expiration & eviction policies (LRU, LFU, TTL)
Cache invalidation techniques
Redis vs Memcached

Redis for High Availability

Redis replication (master–replica setup)
Sentinel for failover
Redis Cluster (sharding & scaling)
Handling partition tolerance

Security & Performance

Redis authentication & ACLs
Encryption & TLS setup
Performance tuning (memory optimization, maxmemory policies)
Benchmarking Redis (redis-benchmark)

Integrations & Clients

Redis client libraries (Java, Python, Node.js, PHP, etc.)
Using Redis with frameworks (Laravel, Django, Spring Boot, Express.js)
Redis as a session store
Redis with message brokers (Kafka, RabbitMQ comparison)

Monitoring & Maintenance

Redis CLI monitoring commands
Redis INFO, MONITOR, SLOWLOG
Logging & debugging
Monitoring tools (RedisInsight, Prometheus, Grafana)
Backup & recovery

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

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

Project - E Commerce Web Application

Deal / Opportunity Management

Project Overview & Setup

Introduction to e-commerce systems
Key modules (Products, Cart, Orders, Payments, Users, Admin)
Tech stack selection
Project structure setup (frontend + backend + database)
Database schema design (Users, Products, Categories, Cart, Orders, Payments, etc.)

User Module

User registration & login (Authentication)
Profile management (edit profile, change password, addresses)
Wishlist / favorites
User roles (Customer, Admin, Vendor)
Session & logout

Product Management

Product catalog (list, view details)
Categories & subcategories
Product attributes (size, color, stock, price)
Product images (upload & gallery)
Search & filtering (price, rating, category)
Sorting (latest, popular, low-high price)

Shopping Cart & Checkout

Add to cart, update quantity, remove items
Save cart for later (session/database)
Display cart summary (items, subtotal, shipping, total)
Checkout process (shipping info, billing info, payment selection)

Order Management

Place order (create order record after checkout)
Order summary page
Order status workflow (Pending ? Processing ? Shipped ? Delivered ? Cancelled)
Order tracking (order history for users)
Email/SMS notifications (order confirmation, shipping update)

Payment Integration

Payment gateways (PayPal, Stripe, Razorpay, etc.)
Cash on Delivery (COD) option
Order validation before payment
Secure payment handling (SSL, tokenization)
Refunds & cancellations

Admin Panel

Dashboard with analytics (sales, orders, users, products)
Manage users (customers, vendors)
Manage products (CRUD, bulk upload via CSV/Excel)
Manage categories & subcategories
Manage orders (update statuses, refunds, cancellations)
Manage payments (view transactions, settlements)
Manage offers & discounts

Discounts, Coupons & Promotions

Add/edit coupons
Apply discounts (percentage, flat, free shipping)
Cart-based discounts (Buy 2 get 1, etc.)
Time-limited offers (Flash sale, seasonal sale)

Shipping & Delivery

Manage shipping addresses
Shipping methods (standard, express, free)
Shipping charges calculation
Integration with courier APIs (FedEx, DHL, etc.)
Delivery tracking system

Reviews & Ratings

Product reviews (add, edit, delete)
Star ratings system
Review moderation (admin approval)
Display average ratings on products

Security

Password hashing & secure login
Role-based access control (RBAC)
Secure checkout with HTTPS
CSRF & XSS protection
Preventing SQL injection
Safe file upload for product images

Reports & Analytics

Sales reports (daily, monthly, yearly)
Product performance (top selling, least selling)
Customer reports (new vs returning)
Payment reports (successful vs failed transactions)
Export reports (CSV/PDF)

API & Mobile Integration

REST API for mobile apps (Products, Cart, Orders, User Auth)
Authentication with JWT / OAuth2
API documentation with Swagger / Postman
Webhooks for order updates

Testing

Unit testing (JUnit / PHPUnit / Jest)
API testing (Postman, Newman)
UI testing (Selenium, Cypress)
Performance testing (JMeter, Locust)

Deployment & Maintenance

Hosting on AWS/DigitalOcean/Heroku
Domain & SSL configuration
Load balancing & scaling
Error logging & monitoring (ELK, Sentry)
Backup & restore strategy

Project - CRM Web Application

Project Overview & Setup

Introduction to CRM system (Modules & Features)
Tools & technologies (HTML, CSS, JS, Bootstrap, PHP/Laravel/CI, Java/Spring, MySQL, REST APIs)
Project folder structure & environment setup
Database design (ER Diagram for CRM: Users, Leads, Contacts, Deals, Tasks, etc.)

User Management Module

User Registration & Login (Authentication)
Roles & Permissions (Admin, Manager, Sales Rep, etc.)
Profile Management (Edit profile, Change password, Upload profile picture)
Session management & logout

Dashboard & Analytics

Admin Dashboard (KPIs, charts, recent activities)
Sales Dashboard (Leads, Deals, Targets)
Activity feed (latest tasks, follow-ups, updates)
Notifications (alerts for tasks, leads, deals)

Lead Management

Add, edit, delete leads
Lead categorization (Hot, Warm, Cold)
Assign leads to sales reps
Import/export leads (Excel/CSV)
Lead conversion to contact/deal

Contact Management

Add, edit, delete contacts
Link contacts with leads and companies
Search & filter contacts
Contact activity history (calls, meetings, emails)

Company / Account Management

Manage organizations/companies
Associate contacts & deals with companies
View company activity history

Task & Activity Management

Create & assign tasks (call, meeting, follow-up)
Task priority & deadlines
Calendar integration (Google Calendar optional)
Activity tracking & reminders

Communication & Notes

Email integration (Send emails via SMTP / API like Gmail/Outlook)
In-app messaging (optional)
Add notes to leads/contacts/deals

File Management

Upload & manage documents for leads/contacts/deals
Secure file storage
File preview & download

Reporting & Analytics

Sales reports (monthly/quarterly performance)
Lead source analysis (from campaigns, referrals, etc.)
Deal pipeline analysis (Won vs Lost)
Export reports (PDF/Excel)
Graphs & charts (using Chart.js, Highcharts, etc.)

API & Integration

REST API for mobile apps or external tools
Authentication via JWT/API tokens
Third-party integrations

Security

Input validation & sanitization
Role-based access control (RBAC)
Data encryption (password hashing, SSL)
Secure API keys/tokens management

Testing

Unit Testing (JUnit/PHPUnit depending on backend)
API Testing (Postman, Newman)
Automated testing pipelines (CI/CD)
Performance testing

Deployment & Maintenance

Deploying on shared hosting / VPS / AWS / DigitalOcean
Domain & SSL setup
Logging & error tracking
Monitoring performance
Backup & recovery plan