DEV Community: Dulan Nithila Liyanarachchi

Building a Real-Time Dashboard with FastAPI, WebSockets, and MySQL

Dulan Nithila Liyanarachchi — Tue, 01 Sep 2026 12:17:13 +0000

I recently worked on a lightweight real-time dashboard built with FastAPI, WebSockets, and aiomysql.

The main goal was simple: retrieve live data from a MySQL database and push updates to the frontend in real time without relying on continuous polling.

This project provided a practical opportunity to explore asynchronous programming, WebSocket communication, and database integration using Python.

Project Overview

The application uses a FastAPI backend to communicate with a MySQL database and a WebSocket endpoint to deliver database updates to connected clients.

The overall architecture can be summarized as:

MySQL Database
      │
      ▼
   aiomysql
      │
      ▼
FastAPI Backend
      │
      ▼
  WebSocket
      │
      ▼
Frontend Dashboard

The WebSocket connection allows the server to push new data directly to the client, making the dashboard capable of displaying updates in real time.

What This Project Demonstrates

The project covers several important backend development concepts:

Setting up Python and the required dependencies
Building an asynchronous FastAPI backend
Connecting to MySQL using aiomysql
Implementing a WebSocket endpoint
Retrieving database records asynchronously
Sending live data to connected clients
Running the application with Uvicorn
Structuring a simple real-time backend application

Why Use WebSockets?

Traditional REST APIs generally follow a request/response model.

For example:

Client → Request → Server
Client ← Response ← Server

If the frontend needs updated information continuously, it may have to repeatedly send requests to the server.

This is commonly known as polling:

Client → Request
Server → Response

Client → Request
Server → Response

Client → Request
Server → Response

With WebSockets, the client establishes a persistent connection with the server:

Client ⇄ WebSocket Connection ⇄ Server

The server can then push new information to the client whenever it becomes available.

This makes WebSockets particularly useful for applications where data needs to be delivered quickly and continuously.

Potential Use Cases

This architecture can be useful for:

Real-time dashboards
Monitoring systems
Live administration panels
Student management systems
Record management applications
System status monitoring
Live data visualization
Notification systems

Documentation and Source Code

I created a complete guide covering the setup and implementation process, including:

Python installation
Required package installation
Project configuration
Server startup
Complete main.py implementation
FastAPI and WebSocket configuration

The GitHub repository also includes the documentation and source code for reference.

GitHub Repository

FastAPI WebSocket Real-Time Dashboard - GitHub Repository

The repository contains:

Complete Guide (PDF)
Source Code (main.py)

Key Technologies

Technology	Purpose
Python	Backend programming
FastAPI	Asynchronous web framework
WebSockets	Real-time client-server communication
aiomysql	Asynchronous MySQL connectivity
MySQL	Database
Uvicorn	ASGI server

Final Thoughts

This project was a useful exercise in combining asynchronous programming, database connectivity, and real-time communication into a practical backend application.

FastAPI and WebSockets provide a straightforward foundation for building applications where data needs to move between the server and client with minimal delay.

I look forward to extending this project with features such as authentication, multiple connected clients, automatic database change detection, improved error handling, and a more advanced frontend dashboard.

If you are working with FastAPI or real-time applications, I'd be interested to hear about your projects and approaches.

Also Published On

This article is also available on the following platforms:

LinkedIn: Read on LinkedIn
Medium: Read on Medium
AWS: Read on AWS

AI - Powered Automatic Email Sending System for File Uploads

Dulan Nithila Liyanarachchi — Tue, 01 Sep 2026 11:24:58 +0000

Introduction

In many organizations and educational environments, users frequently upload documents and then need to manually prepare and send emails containing information about those files.

This repetitive process can be time-consuming and inefficient.

To address this, I developed an AI-powered automatic email sending system that combines file uploads, document text extraction, AI-generated email content, and automated email delivery into a single workflow.

The project demonstrates how AI APIs can be integrated into a traditional PHP web application to automate document-based communication.

Project Overview

The system provides a web-based interface where users can upload documents.

Once a file is uploaded, the application:

Validates the uploaded file.
Extracts text from the document.
Sends the extracted content to an AI API.
Generates professional email content using AI.
Automatically sends the email using PHPMailer.
Displays success or error notifications to the user.

This creates a streamlined workflow:

Document Upload
      ↓
File Validation
      ↓
Text Extraction
      ↓
AI Processing
      ↓
Email Generation
      ↓
Automated Email Sending
      ↓
User Notification

Key Features

Smart File Upload Handling

The application provides a simple and responsive interface for uploading documents.

Before processing, uploaded files are validated to ensure that only supported and valid files are handled.

AI-Generated Email Content

Instead of manually writing an email for every uploaded document, the system uses an AI API to analyze the extracted document content and generate a professional email message.

This reduces repetitive work while maintaining consistent communication.

Automated Email Sending

After generating the email content, the system automatically sends the email to the intended recipient using PHPMailer.

This removes the need for users to manually copy the generated content and send the email themselves.

Multi-Format Document Processing

The system supports text extraction from multiple document formats, including:

PDF documents
Microsoft Word documents
Presentation files

The extracted text is then passed to the AI processing stage.

User-Friendly Notifications

Toast notifications and session-based alerts provide feedback to users throughout the workflow.

Users can easily identify whether an upload or email operation was successful or encountered an error.

Technologies Used

Backend

PHP
PHPMailer
AI API Integration

Document Processing

Smalot PDF Parser
PHPWord
PHP Presentation Reader

Frontend

HTML
CSS
JavaScript

System Workflow

The overall process can be represented as follows:

User
 │
 ▼
Upload Document
 │
 ▼
File Validation
 │
 ▼
Document Text Extraction
 │
 ▼
AI API Processing
 │
 ▼
Generate Email Content
 │
 ▼
PHPMailer
 │
 ▼
Send Email
 │
 ▼
Success / Error Notification

The main objective is to automate the communication process without requiring the user to manually read the uploaded document, write an email, and send it.

Why This Project Matters

Manual email preparation can become a bottleneck when organizations regularly process documents.

For example, consider an educational platform where lecturers upload course materials or reports and need to notify students or administrators whenever a document is uploaded.

Instead of:

Upload → Read Document → Write Email → Send Email

the process can be automated as:

Upload → AI Processing → Email Sent

This can help to:

Improve productivity
Reduce repetitive manual tasks
Improve communication consistency
Integrate AI into existing applications
Automate document-based workflows

Challenges Faced

Building the system involved several technical challenges.

Handling Different File Formats

Different document formats require different approaches for extracting their content.

Separate document-processing libraries were integrated to handle PDFs, Word documents, and presentation files.

Extracting Usable Text

Extracted document content is not always perfectly structured.

The system therefore needs to process the extracted content before sending it to the AI API.

AI Integration

Integrating AI-generated content into an automated backend workflow required handling API requests, responses, errors, and generated content appropriately.

Automated Email Delivery

Email delivery introduced additional considerations such as SMTP configuration, error handling, and secure handling of email credentials.

User Experience

Since multiple operations take place during the workflow, providing clear feedback to the user was important.

Toast notifications and session-based messages were implemented to make the process easier to understand.

Future Improvements

There are several features planned for future versions:

Support for additional file formats
AI-generated email subject suggestions
Email scheduling
Recipient management dashboard
Upload history tracking
Enhanced security and validation
Multi-user authentication
Processing and email delivery logs

These improvements could make the system more suitable for larger organizational environments.

Source Code

The complete source code is available on GitHub:

GitHub Repository - AI-Powered Automatic Email Sending System

Feel free to explore the project, provide feedback, or contribute improvements.

Conclusion

This project was a practical exploration of how AI can be integrated into existing web applications to automate repetitive workflows.

By combining:

File Uploads + Document Processing + AI + Email Automation

the system provides a practical approach to automating document-based communication.

The project also provided hands-on experience with PHP backend development, document parsing, API integration, automated email delivery, and workflow automation.

I look forward to further improving the project and exploring more ways to integrate AI into practical software solutions.

Also Published On

This article is also available on the following platforms:

LinkedIn: Read on LinkedIn
Medium: Read on Medium
AWS: Read on AWS