AI automation

 *FREE 30 DAYS AI AUTOMATION CHALLENGE COURSE @EXPRESS TECH ACADEMY* 

 *Begins:* Tuesday,  7th July 2026

 *DURATION:* TWO MONTHS COURSE (There will be 48hrs interval to each classes for practicals to be done)

 *_CERTIFICATION AVAILABLE AFTER TRAINING_* 

 *DAY 01* 

Topic: Introduction To Ai Automation 

Time: 21:15 minutes

 *DAY 02* 

 *Topic:* Installation and configuration of n8n (+n8n set up locally)

 *Time:* 29:37 minutes 

 *DAY 03*

 *TOPIC:* Triggers, Nodes and connections 

Time: 14:44 minutes

 *DAY 04*

TOPIC: JSON and Data Types

Time: 17:45 minutes

 *DAY 05*

TOPIC: Building your first workflow (Variables and Expression)

Time: 24:24 minutes

 *DAY 06*

TOPIC: Building your own Chatbolt from scratched

Time: 16:02 minutes 

 *DAY 07* 

TOPIC: Building Your ai Agent For Custimer Support 

 *DAY 08* 

TOPIC: Create Google Cloud credentials and openai credentials 

Time: 21:25 minutes

 *DAY 09*

TOPIC: Build An automated Content Generator agent using HTTP request 

Time: 28:28 minutes

 *DAY 10*

TOPIC: Building a WhatsApp chat bot agent that can help you responds  your messages 

Time: 30:31 minutes

 *DAY 11*

TOPIC: Building a rag pipeline with pinecone to help your workflow

Time: 22:12 minutes

 *DAY 12* 

TOPIC:  Building a LinkedIn post and image generator for direct posting 

Time: 34:57 minutes

 *DAY 13* 

TOPIC: Creearing a voice chat bot that sends messages automatically with just a voice 

Time: 32:15 minutes

 *DAY 14* 

TOPIC: Workflow Hack with chatgpt. How to build a complete workflow with a single prompt on chatgpt

Time: 8:14 minutes

 *DAY 15* 

TOPIC: Building a telegram chatbot [Introducing Human in the loop]

Time: 35:10 minutes

 *DAY 16*

TOPIC: Building a telegram voice trigger agent with chatbot

Time: 20:10 minutes

 *DAY 17* 

TOPIC: Mistakes you should not make in Building any workflow

Time: 14:33 minutes

 *DAY 18* 

TOPIC: Building the front end of your workflow with magnus. And integrating it in your website or business 

Time: 13:54 minutes

 *DAY 19* 

TOPIC: APIs Explained. Knowing what APIs are and how to use them

Time: 17:39 minutes

 *DAY 20* 

TOPIC: Job search Automation. Building an automation that automatically research for jobs and apply for jobs on your behalf every day

Time: 42:54 minutes

 *DAY 21* 

TOPIC: setting automations that  Scrape Emails and contacts from LinkedIn and Google map

Time: 15:18 minutes 

 *DAY 22* 

TOPIC: Installation and overview of Antigravity, n8n chathub and catchup

Time: 9:49 minutes 

 *DAY 23* 

TOPIC: Building the user interface for your workflows using Antigravity 

Time: 14:26 minutes 

 *DAY 24* 

TOPIC: Connecting n8n to Instagram and getting it ready for automations 

Time: 14:09 minutes

 *DAY 25* 

TOPIC: automating Instagram  reels

Time: 26:39 minutes

 *DAY 26* 

TOPIC: Automate Instagram image and captions

Time: 27:12 minutes

 *DAY 27* 

TOPIC: Creating and connecting multiple Ai Agents for Automation

Time: 27:37 minutes

 *DAY 28* 

TOPIC:  PDF Extraction with automation 

Time: 19:10 minutes 

 *DAY 29* 

TOPIC: Handling errors automatically in your workflows

Time: 15:17 minutes

 *DAY 30* 

TOPIC: The business of AI Automation: Landing multiple clients as an ai automation builder 

Time: 12:32 minutes

 *The class holds here* 👇👇

Registering superadmin Models

 

WEEK 10 – THURSDAY

TOPIC: Registering Models (Showing Data in the Django Admin Panel)

Learning Objectives

At the end of this lesson, students should be able to:

1. Explain what a Django model is.

2. Explain the purpose of the Django Admin Panel.

3. Register a model in the Admin Panel.

4. View and manage model data through the Admin Panel.

---

Introduction

In the previous lesson, we created a Student model and stored student information in the MySQL database.

However, even though the data is stored in the database, Django will not display it in the Admin Panel until the model is registered.

Today, we will learn how to register a model so that it appears in the Django Admin Panel.

---

What is a Model?

A model is a Python class that represents a table in the database.

For example:

class Student(models.Model):
    full_name = models.CharField(max_length=100)
    email = models.EmailField()
    course = models.CharField(max_length=100)

What we are doing

We created a model named Student. Django used this model to create a table named students_student in the database.

---

What is the Django Admin Panel?

The Django Admin Panel is a built-in website provided by Django for administrators.

It allows administrators to:

• Add new records

• View records

• Edit records

• Delete records

• Manage users

• Manage registered models

The default Admin Panel address is:

http://127.0.0.1:8000/admin/

---

Why Do We Register Models?

By default, Django does not show your models in the Admin Panel.

We register a model to tell Django:

"Display this model in the Admin Panel so administrators can manage its data."

---

STEP 1: Open the admin.py File

Open:

students/admin.py

What we are doing

We are opening the file responsible for registering models in the Django Admin Panel.

Initially, the file looks like this:

from django.contrib import admin

# Register your models here.

---

STEP 2: Import the Student Model

Add the following line:

from .models import Student

Your file now becomes:

from django.contrib import admin
from .models import Student

What we are doing

We are importing the Student model from the models.py file so that Django knows which model we want to register.

Meaning of the code

Code	Meaning
from	Bring something from another file
.	Refers to the current app (students)
models	The models.py file
import	Bring into this file
Student	The model we want to register

---

STEP 3: Register the Model

Below the import statements, write:

admin.site.register(Student)

Your complete admin.py file should look like this:

from django.contrib import admin
from .models import Student

admin.site.register(Student)

What we are doing

We are telling Django:

"Display the Student model in the Admin Panel."

Meaning of the code

Code	Meaning
admin	Django's administration system
site	Refers to the Django Admin website
register()	Registers a model so it appears in the Admin Panel
Student	The model to be displayed

---

STEP 4: Start the Django Server

Run the following command:

python manage.py runserver

What we are doing

We are starting the Django development server so we can access the Admin Panel through a web browser.

---

STEP 5: Open the Admin Panel

Open your browser and visit:

http://127.0.0.1:8000/admin/

What we are doing

We are opening Django's built-in administration website.

---

STEP 6: Log In

Enter the superuser username and password you created earlier.

Example:

Username: admin
Password: ********

What we are doing

We are signing in as the administrator to access and manage application data.

---

STEP 7: View the Student Model

After logging in, you should see a section named Students.

Click Students.

What we are doing

We are opening the Student model to view all student records stored in the database.

If no records have been added yet, the list will be empty.

---

STEP 8: Add a New Student

Click Add Student.

Fill in the fields:

• Full Name

• Email

• Course

Click Save.

What we are doing

We are creating a new student record using the Django Admin Panel. Django saves the information directly into the students_student table in the MySQL database.

---

STEP 9: Edit a Student Record

Click on any student's name.

Update the information.

Click Save.

What we are doing

We are modifying an existing record in the database.

---

STEP 10: Delete a Student Record

Select a student record.

Click Delete and confirm.

What we are doing

We are removing the selected record from the database.

---

Summary

Create Student model
        ↓
Open admin.py
        ↓
Import Student model
        ↓
Register the model
        ↓
Run the server
        ↓
Open http://127.0.0.1:8000/admin/
        ↓
Log in as superuser
        ↓
Manage student records through the Admin Panel

Class Exercise

1. Register the Student model in admin.py.

2. Log in to the Django Admin Panel.

3. Add three student records.

4. Edit one student's course.

5. Delete one student record.

6. Verify that the changes are reflected in the MySQL database by running:

SELECT * FROM students_student;

This exercise helps students understand how Django's Admin Panel provides a simple interface for managing database records without writing SQL queries manually.

TOPIC: Creating a Django Superuser

 # TOPIC: Creating a Django Superuser

## Meaning of a Superuser

A **Superuser** is the administrator of a Django application. A superuser has full permissions to manage the project through Django's built-in **Admin Panel**.

A superuser can:

* Add new records

* View records

* Edit records

* Delete records

* Manage users

* Manage all registered models

Think of a superuser as the **system administrator** or **owner** of the application.

---

# Prerequisites

Before creating a superuser, ensure that:

* Django is installed.

* Your project is created.

* The database is connected.

* You have run the migrations:

```bash

python manage.py migrate

```

### What we are doing

We are creating all the required Django database tables, including the table that stores user accounts.

---

# STEP 1: Open the Terminal

### What we are doing

We are opening the terminal or Command Prompt in the Django project folder where the `manage.py` file is located.

Example:

```text

student_portal/

│── manage.py

│── config/

│── students/

```

---

# STEP 2: Create the Superuser

Run the following command:

```bash

python manage.py createsuperuser

```

### What we are doing

We are telling Django to create an administrator account.

### Meaning of the command

| Code | Meaning |

| ----------------- | ---------------------------------------------------------- |

| `python` | Runs the Python interpreter. |

| `manage.py` | Django's management script used to perform project tasks. |

| `createsuperuser` | Creates a new administrator account with full permissions. |

---

# STEP 3: Enter the Username

After running the command, Django will ask:

```text

Username:

```

Example:

```text

Username: admin

```

### What we are doing

We are creating the login name for the administrator.

The username is used when logging into the Django Admin Panel.

---

# STEP 4: Enter the Email Address

Django will ask:

```text

Email address:

```

Example:

```text

admin@gmail.com

```

### What we are doing

We are providing the administrator's email address.

This field is optional by default, but it is recommended to provide one.

---

# STEP 5: Enter the Password

Django will ask:

```text

Password:

```

Example:

```text

********

```

### What we are doing

We are creating a secure password for the administrator account.

**Note:** For security reasons, the password will not be displayed as you type.

---

# STEP 6: Confirm the Password

Django will ask:

```text

Password (again):

```

Type the same password again.

### What we are doing

We are confirming the password to ensure it was entered correctly.

---

# STEP 7: Superuser Created Successfully

If everything is correct, Django will display:

```text

Superuser created successfully.

```

### What we are doing

Django has saved the administrator's account in the database.

---

# STEP 8: Start the Django Server

Run:

```bash

python manage.py runserver

```

### What we are doing

We are starting the Django development server so we can access the Admin Panel through a web browser.

---

# STEP 9: Open the Django Admin Panel

Open your web browser and go to:

```text

http://127.0.0.1:8000/admin/

```

### What we are doing

We are opening Django's built-in administration website.

---

# STEP 10: Log In

Enter the credentials you created:

* **Username:** `admin`

* **Password:** (the password you chose)

Click **Log in**.

### What we are doing

We are signing in as the administrator to manage the application's data.

---

# What You Will See

After logging in, you will see the Django Admin Dashboard.

If you registered the `Student` model in `students/admin.py`, you will also see a **Students** section where you can:

* Add new students

* View all students

* Edit student details

* Delete student records

---

# Summary

```text

Run migrations

        ↓

Create superuser

        ↓

Enter username

        ↓

Enter email

        ↓

Enter password

        ↓

Superuser created

        ↓

Run the server

        ↓

Visit http://127.0

.0.1:8000/admin/

        ↓

Log in to the Django Admin Panel

```

This is the standard process for creating and using a Django superuser.

TOPIC: Creating a Student Registration Form and Saving Data to MySQL

 

WEEK 10 – TUESDAY

TOPIC: Creating a Student Registration Form and Saving Data to MySQL

Learning Objectives

At the end of this lesson, students should be able to:

• Create an HTML form.

• Understand the <form> tag and form fields.

• Submit data from a webpage.

• Save student information into the MySQL database using Django.

• Verify that the data has been saved.

---

What We Are Doing

In the previous lesson, we created a Home page and a Register page.

The Register page only displayed text.

Today, we will make it functional by creating a form that allows users to enter:

• Full Name

• Email

• Course

When the user clicks Register, the information will be saved into the students_student table in MySQL.

---

STEP 1: Open register.html

Open:

students/templates/register.html

What We Are Doing

We are replacing the placeholder text with a real registration form.

Replace the content with:

<!DOCTYPE html>
<html>
<head>
    <title>Student Registration</title>
</head>
<body>

<h1>Student Registration Form</h1>

<a href="/">
    <button>Home</button>
</a>

<hr>

<form method="POST">

    {% csrf_token %}

    <label>Full Name</label><br>
    <input type="text" name="full_name"><br><br>

    <label>Email</label><br>
    <input type="email" name="email"><br><br>

    <label>Course</label><br>
    <input type="text" name="course"><br><br>

    <button type="submit">
        Register Student
    </button>

</form>

</body>
</html>

---

Explanation of the Code

<form method="POST">

What We Are Doing

We are creating a form that sends data to Django.

Code	Meaning
<form>	Starts a form
method="POST"	Sends data securely to the server

---

{% csrf_token %}

What We Are Doing

We are protecting the form against unauthorized requests.

Code	Meaning
{% %}	Django template tags
csrf_token	Security token required for POST forms

Without this line, Django will reject the form submission.

---

Full Name Field

<input type="text" name="full_name">

What We Are Doing

Creating a textbox for the student's full name.

Code	Meaning
input	Creates an input field
type="text"	Accepts text
name="full_name"	Field name sent to Django

---

Email Field

<input type="email" name="email">

What We Are Doing

Creating an email input field.

The browser checks that the value looks like an email address.

---

Course Field

<input type="text" name="course">

What We Are Doing

Creating a textbox for the student's course.

---

Submit Button

<button type="submit">
Register Student
</button>

What We Are Doing

Creating a button that submits the form.

---

STEP 2: Open views.py

Open:

students/views.py

---

What We Are Doing

We are telling Django:

"When someone submits the form, save the information into the database."

Replace the register() function with:

from django.shortcuts import render, redirect
from .models import Student

def register(request):

    if request.method == "POST":

        full_name = request.POST["full_name"]
        email = request.POST["email"]
        course = request.POST["course"]

        Student.objects.create(
            full_name=full_name,
            email=email,
            course=course
        )

        return redirect("/")

    return render(request, "register.html")

---

Explanation of the Code

Import

from django.shortcuts import render, redirect

What We Are Doing

Importing two tools.

Code	Meaning
render	Displays an HTML page
redirect	Sends the user to another page

---

from .models import Student

What We Are Doing

Importing the Student model so we can save data.

---

Check Request Method

if request.method == "POST":

What We Are Doing

Checking whether the user clicked the Register Student button.

If yes, continue.

---

Get Form Data

full_name = request.POST["full_name"]

What We Are Doing

Getting the value entered into the Full Name textbox.

The same happens for:

email = request.POST["email"]
course = request.POST["course"]

---

Save to Database

Student.objects.create(
    full_name=full_name,
    email=email,
    course=course
)

What We Are Doing

Creating a new student record in the MySQL table.

Code	Meaning
Student	Our model
objects	Django's manager for database operations
create()	Insert a new row into the table

---

Redirect

return redirect("/")

What We Are Doing

After saving the record, send the user back to the Home page.

---

STEP 3: Run the Server

python manage.py runserver

Open:

http://127.0.0.1:8000/register/

Fill in the form:

• Full Name: Aisha Bello

• Email: aisha@gmail.com

• Course: Web Development

Click Register Student.

The data will be saved into the students_student table.

---

STEP 4: Verify the Data

Open MySQL Workbench.

Select the database:

USE student_portal;

View all students:

SELECT * FROM students_student;

What We Are Doing

We are asking MySQL to display every record stored in the students_student table.

If everything worked correctly, you'll see the student details you entered.

---

Practical Exercise

1. Register five students using the form.

2. Use SELECT * FROM students_student; to confirm they were saved.

3. Check the data again in the Django Admin panel (/admin/) and compare it with the records shown in MySQL Workbench.

This completes a full cycle: the user enters data on a webpage, Django processes it, and MySQL stores it permanently.

Topic: Creating a Web Page with Home and Register Buttons

 WEEK 9 – THURSDAY (CONTINUATION)

Django note

Learning Objectives

At the end of this lesson, students should be able to:

• Create a Django view.

• Create an HTML template.

• Create navigation buttons.

• Connect URLs to views.

• Display a webpage in the browser.

---

STEP 1: Create a Templates Folder

What we are doing

We need a place to store our HTML pages. Django looks for HTML files inside a folder called templates.

Inside your students app, create this folder:

students/
│── templates/

Inside templates, create a file named:

home.html

---

STEP 2: Create the Home Page

What we are doing

We are designing the first page users will see when they open the website.

Open:

students/templates/home.html

Paste:

<!DOCTYPE html>
<html>
<head>
    <title>Student Management System</title>
</head>
<body>

    <h1>Welcome to Student Management System</h1>

    <a href="/">
        <button>Home</button>
    </a>

    <a href="/register/">
        <button>Register</button>
    </a>

</body>
</html>

Explanation

• <!DOCTYPE html> – Tells the browser this is an HTML5 document.

• <html> – Starts the webpage.

• <head> – Contains information about the page.

• <title> – The title shown on the browser tab.

• <body> – Everything the user sees.

• <h1> – A large heading.

• <a> – Creates a hyperlink.

• href="/" – Links to the Home page.

• <button> – Creates a clickable button.

---

STEP 3: Create the Home View

What we are doing

A view decides what Django should display when a user visits a page.

Open:

students/views.py

Replace the previous code with:

from django.shortcuts import render

def home(request):
    return render(request, "home.html")

Explanation

• render – Displays an HTML page.

• home – Function that handles the Home page.

• request – Information sent by the browser.

• "home.html" – The HTML page to display.

---

STEP 4: Create the Register View

What we are doing

We are creating another page called Register.

Add this below the home view:

def register(request):
    return render(request, "register.html")

This tells Django to display register.html when the Register page is requested.

---

STEP 5: Create the Register Page

Inside the templates folder, create:

register.html

Paste:

<!DOCTYPE html>
<html>
<head>
    <title>Register Student</title>
</head>
<body>

    <h1>Student Registration Page</h1>

    <a href="/">
        <button>Home</button>
    </a>

    <a href="/register/">
        <button>Register</button>
    </a>

    <p>This page will contain the student registration form later.</p>

</body>
</html>

---

STEP 6: Create URL Patterns

What we are doing

URLs tell Django which view to run when a user visits a particular web address.

Open:

students/urls.py

Replace it with:

from django.urls import path
from . import views

urlpatterns = [
    path("", views.home, name="home"),
    path("register/", views.register, name="register"),
]

Explanation

• path() – Creates a URL.

• "" – The Home page (/).

• "register/" – The Register page (/register/).

• views.home – Calls the home view.

• views.register – Calls the register view.

• name – Gives the URL a name that can be used elsewhere in Django.

---

STEP 7: Run the Server

What we are doing

We are starting Django so we can test the website.

Run:

python manage.py runserver

Open:

http://127.0.0.1:8000/

You should see:

• Welcome to Student Management System

• Home button

• Register button

When you click Register, it should open:

http://127.0.0.1:8000/register/

and display the Student Registration Page.

---

Expected Result

The website will have two simple pages:

Home Page

------------------------------------
Welcome to Student Management System

[ Home ]   [ Register ]
------------------------------------

Register Page

------------------------------------
Student Registration Page

[ Home ]   [ Register ]

This page will contain the student
registration form later.
------------------------------------

This is a good foundation because in the next lesson you can replace the placeholder text on the Register page with a real HTML form that saves student information into your MySQL database.

Django Table

 

WEEK 9 – THURSDAY

TOPIC: Creating a Database Table in Django Using MySQL

Sub-topic: Creating a Student Table with Django Models and Migrations

---

What We Are Doing in This Practical

We already have:

• A Django project

• A Django app called students

• A MySQL database called student_portal

• Django connected to MySQL in settings.py

Now, we want to create a Student table inside the student_portal database.

The table will store:

• Student full name

• Student email

• Student course

---

STEP 1: Open the models.py File

Go to this file:

students/models.py

What we are doing

We are opening the file where Django allows us to describe a database table using Python code.

In Django, we do not need to first create the table manually in MySQL. We create a model in models.py, and Django uses it to create the table for us.

---

STEP 2: Import Django Database Tools

Inside students/models.py, write:

from django.db import models

What we are doing

We are bringing Django’s database tools into our file.

We need these tools because they help us create:

• Tables

• Columns

• Text fields

• Email fields

• Number fields

• Date fields

Meaning of the code

Code	Meaning
from	Take something from another place
django	The Django framework
.db	Django database section
import	Bring a tool into this file
models	Tools for creating tables and columns

---

STEP 3: Create the Student Model

Under the import line, write:

class Student(models.Model):

What we are doing

We are creating a Django model called Student.

A model is like a blueprint for a database table.

Django will use this blueprint to create a table for students inside MySQL.

Meaning of the code

Code	Meaning
class	Create a blueprint/template
Student	The name of our model
models.Model	Tells Django that this is a database table
:	Starts the code inside the model

Table name Django will create

Because our app is called students and our model is called Student, Django will normally create:

students_student

---

STEP 4: Create the Full Name Column

Inside the Student model, write:

full_name = models.CharField(max_length=100)

What we are doing

We are creating a column called full_name.

This column will store each student’s name.

Examples:

Musa Ibrahim
Aisha Bello
John David

Meaning of the code

Code	Meaning
full_name	Name of the column
=	Give this column a field type
models.CharField	Store short text
max_length=100	Allow a maximum of 100 characters

---

STEP 5: Create the Email Column

Write:

email = models.EmailField()

What we are doing

We are creating a column called email.

This column will store each student’s email address.

Examples:

musa@gmail.com
aisha@gmail.com

Meaning of the code

Code	Meaning
email	Name of the column
=	Give this column a field type
models.EmailField()	Store email addresses and check email format

---

STEP 6: Create the Course Column

Write:

course = models.CharField(max_length=100)

What we are doing

We are creating a column called course.

This column will store the course each student is studying.

Examples:

Python Programming
Web Development
Data Analysis

Meaning of the code

Code	Meaning
course	Name of the column
models.CharField	Store short text
max_length=100	Allow a maximum of 100 characters

---

STEP 7: Save the Complete Model

Your complete students/models.py file should look like this:

from django.db import models

class Student(models.Model):
    full_name = models.CharField(max_length=100)
    email = models.EmailField()
    course = models.CharField(max_length=100)

What we have done

We have created the blueprint for a student table.

At this point, the table is not yet inside MySQL. Django only knows what the table should look like.

---

STEP 8: Create a Migration File

Open your terminal inside the project folder where manage.py is located.

Run:

python manage.py makemigrations

What we are doing

We are telling Django:

“Look at my model and prepare instructions for creating the table.”

Django creates a migration file inside:

students/migrations/

You may see:

Migrations for 'students':
  students/migrations/0001_initial.py
    + Create model Student

Meaning of the command

Code	Meaning
python	Run Python
manage.py	Django command file
makemigrations	Create instructions for database changes

---

STEP 9: Send the Table to MySQL

Run:

python manage.py migrate

What we are doing

We are telling Django:

“Use the migration instructions and create the table inside the MySQL database.”

Django connects to the database named student_portal because that is the database name written in settings.py.

After this command, the students_student table is created inside MySQL.

Meaning of the command

Code	Meaning
python	Run Python
manage.py	Django command file
migrate	Apply the migration instructions to the database

---

STEP 10: Check the Table in MySQL

Open MySQL Workbench.

Run:

USE student_portal;

What we are doing

We are selecting the database where our table was created.

Meaning of the code

Code	Meaning
USE	Select a database
student_portal	The database name
;	End the MySQL command

---

STEP 11: Show All Tables

Run:

SHOW TABLES;

What we are doing

We are asking MySQL to show every table inside the student_portal database.

You should see:

students_student

You may also see Django tables such as:

auth_user
django_admin_log
django_migrations
django_session

---

STEP 12: Check the Columns in the Student Table

Run:

DESCRIBE students_student;

What we are doing

We are asking MySQL to show the columns inside the students_student table.

You should see columns similar to:

Column	Meaning
id	Automatic student number created by Django
full_name	Student’s full name
email	Student’s email
course	Student’s course

---

Final Summary

Create Student model in models.py
        ↓
Create migration with makemigrations
        ↓
Run migrate
        ↓
Django creates students_student table in MySQL
        ↓
Check the table in MySQL Workbench

MySQL Workbench

 

Complete Guide: Reinstall MySQL Workbench + MySQL Server (Windows)

This will completely reinstall everything properly so your connection works.

---

PART 1 — Remove Old Installation

Step 1: Uninstall MySQL

Press:

Windows + R

Type:

appwiz.cpl

Press Enter.

---

Step 2: Remove All MySQL Programs

Uninstall anything named:

• MySQL Workbench

• MySQL Server

• MySQL Installer

• MySQL Shell

• Connector

Remove all MySQL items.

Restart your PC after uninstalling.

---

PART 2 — Download MySQL

Step 3: Download Installer

Open:

MySQL Community Installer

Download:

mysql-installer-web-community

or full installer.

---

PART 3 — Install MySQL Correctly

Step 4: Open Installer

Double-click the installer.

Click:

• Yes (if Windows asks permission)

---

Step 5: Choose Setup Type

Select:

Developer Default

This installs:

• MySQL Server

• MySQL Workbench

• Shell

• Drivers

Click:

• Next

---

Step 6: Install Required Packages

If prompted:

• Click Execute

Wait for installation.

Then:

• Next

---

PART 4 — Configure MySQL Server

Step 7: Configuration Type

Leave defaults:

Option	Value
Config Type	Development Computer
Protocol	TCP/IP
Port	3306

Click:

• Next

---

Step 8: Authentication Method

Choose:

Use Strong Password Encryption

Click:

• Next

---

Step 9: Create Root Password

Create password.

Example:

Admin123

Write it down somewhere safe.

Click:

• Next

---

Step 10: Windows Service

Leave defaults:

Option	Value
Service Name	MySQL80
Start at Startup	Checked

Click:

• Next

---

Step 11: Apply Configuration

Click:

• Execute

Wait for all green checkmarks ✅

Then:

• Finish

---

PART 5 — Open MySQL Workbench

Step 12: Launch Workbench

Press Windows key.

Search:

MySQL Workbench

Open it.

---

PART 6 — Create Connection

Step 13: Create New Connection

On the home screen:

• Click the ➕ plus icon

Fill in:

Field	Value
Connection Name	Local MySQL
Hostname	127.0.0.1
Port	3306
Username	root

---

Step 14: Add Password

Click:

• Store in Vault

Enter your password:

• Example: Admin123

Click:

• OK

---

Step 15: Test Connection

Click:

• Test Connection

You should see:

Successfully made the MySQL connection

Click:

• OK

---

PART 7 — Start Writing SQL

Double-click your connection.

Click the SQL tab.

Paste:

CREATE DATABASE school;

USE school;

CREATE TABLE students (
    id INT PRIMARY KEY,
    name VARCHAR(50)
);

INSERT INTO students VALUES (1, 'John');

SELECT * FROM students;

Run using:

• ⚡ lightning icon

---

If It Still Does Not Work

Check service:

Press:

Windows + R

Type:

services.msc

Find:

• MySQL80

Status should be:

• Running

If not:

• Right-click → Start

---

Official MySQL Resources

MySQL Workbench Documentation

MySQL Server Documentation