DEV Community: Dulan Nithila Liyanarachchi

Check out my CoderLegion profile & latest post!

Dulan Nithila Liyanarachchi — Tue, 22 Sep 2026 06:46:47 +0000

🏆 Points: 245 | 🎱 Badges: 16 | 👥 Followers: 6 | 📄 Posts: 4

Latest post: "A Complete Guide to Install XAMPP, Configure Apache & MySQL Services, and Deploy WordPress Using Pow"
Read it here: https://coderlegion.com/26591/complete-guide-install-xampp-configure-apache-mysql-services-and-deploy-wordpress-using

View my full profile: https://coderlegion.com/user/dulannithilaliyanarachchi

A Complete Guide to Install XAMPP, Configure Apache & MySQL Services, and Deploy WordPress Using PowerShell Commands

Dulan Nithila Liyanarachchi — Wed, 02 Sep 2026 16:09:44 +0000

Setting up a reliable local web development environment is one of the first steps for anyone working with WordPress, PHP, MySQL, or Apache. While XAMPP makes this process easier by bundling the required components into a single package, configuring the environment properly, especially through the command line, can still be challenging.

Many online tutorials focus only on the graphical interface and often skip essential configuration steps, troubleshooting techniques, or service management. As a result, beginners frequently encounter issues with Apache, MySQL, PHP compatibility, phpMyAdmin, or WordPress installation.

To address these challenges, I created a comprehensive guide that demonstrates how to install, configure, and manage an entire XAMPP and WordPress development environment using Windows PowerShell.

Whether you're a student learning web technologies, an educator preparing laboratory sessions, or a developer looking for a repeatable deployment process, this guide provides a structured approach from start to finish.

Why This Guide?

A properly configured local development environment saves hours of troubleshooting and creates a consistent workflow for development, testing, and learning.

Instead of relying solely on mouse clicks, this guide introduces a command-driven approach that helps users understand what happens behind the scenes while also making the installation process easier to reproduce across multiple machines.

The guide follows a complete workflow covering installation, service management, WordPress deployment, version upgrades, and troubleshooting.

What You'll Learn

The guide covers every major step required to build a local WordPress development environment.

1. XAMPP Installation

Learn how to install XAMPP using PowerShell commands, verify the installation, and safely uninstall and reinstall it when necessary.

Topics include:

Downloading XAMPP
Silent installation
Installation verification
Troubleshooting incomplete installations
Safe uninstallation

2. Apache Service Configuration

Apache is configured as a Windows Service, allowing it to be managed directly through PowerShell.

You'll learn how to:

Install Apache as a service
Verify service status
Start and stop Apache
Manage services efficiently
Troubleshoot service-related issues

3. MySQL Service Installation

Database configuration is an essential part of every WordPress deployment.

This section explains how to:

Install MySQL as a Windows Service
Verify successful installation
Start and stop the service
Prepare the database environment for WordPress

4. WordPress Deployment on XAMPP

One of the largest sections of the guide walks through deploying WordPress on a local server.

Topics include:

Creating WordPress databases
Configuring users and permissions
Downloading WordPress
Extracting and organizing files
Running the installation
Configuring the initial website
Accessing the WordPress dashboard

5. Upgrading PHP

Modern WordPress versions require newer PHP releases.

The guide explains how to safely:

Replace outdated PHP versions
Configure php.ini
Enable required PHP extensions
Update Apache configuration
Verify the installation

6. Upgrading phpMyAdmin

Many bundled XAMPP installations include older versions of phpMyAdmin.

The guide demonstrates:

Installing the latest release
Preserving existing configurations
Migrating settings safely
Verifying successful upgrades

7. Daily Service Management

Instead of opening the XAMPP Control Panel every time, the guide shows how to manage services directly from PowerShell.

This includes:

Starting Apache
Starting MySQL
Opening WordPress
Accessing phpMyAdmin
Stopping services after development

Why Use PowerShell Instead of Only the XAMPP Control Panel?

Learning to manage services through PowerShell provides several long-term advantages.

Faster setup
Easier automation
Better troubleshooting
Repeatable deployments
Improved understanding of Windows service management
Practical DevOps and system administration skills

These skills become increasingly valuable when working with larger development environments or automating deployments.

Who Should Read This Guide?

This guide is suitable for:

Web Developers
WordPress Developers
PHP Developers
Computer Science Students
Information Technology Students
Software Engineering Undergraduates
Lecturers and Instructors
System Administrators
Beginners learning local web development

It is especially useful in academic environments where students need to deploy multiple local development environments using consistent procedures.

GitHub Repository

The complete guide and supporting resources are available on GitHub.

GitHub Repository:

XAMPP-WordPress-PowerShell-Guide

If you find this resource useful, consider giving the repository a star. It helps increase visibility and encourages further improvements.

Also Published On

This article is also available on the following platforms:

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

Acknowledgements

I would like to express my sincere gratitude to Mr. Madusanka Mithrananda for his invaluable guidance, encouragement, and continuous support throughout the development of this guide and the article. His expertise, constructive feedback, and mentorship were instrumental in shaping this work and deepening my understanding of XAMPP, PowerShell, and WordPress deployment.

I truly appreciate his dedication to teaching, willingness to share knowledge, and the encouragement provided throughout this journey. His guidance has been an invaluable part of the successful completion of this guide.

Final Thoughts

Documentation is one of the most valuable yet overlooked contributions to the developer community. A clear, repeatable guide can save countless hours for students, developers, and educators trying to build reliable development environments.

This project was created with the goal of simplifying the setup process while encouraging developers to understand the underlying configuration instead of simply following GUI-based installation steps.

I hope it serves as a practical reference for anyone working with XAMPP, Apache, MySQL, PHP, PowerShell, and WordPress.

If you have suggestions, discover improvements, or would like to contribute, feel free to open an issue or submit a pull request on GitHub.

Happy coding!

Building a Real-Time Payment Gateway Integration with PHP, PayHere, ngrok, and MySQL

Dulan Nithila Liyanarachchi — Wed, 02 Sep 2026 14:59:07 +0000

Recently, I built a complete real-time payment gateway integration using PHP, PayHere Sandbox, ngrok, and MySQL to simulate and test online payments in a local development environment.

This project covered:

Secure PayHere checkout integration
Real-time payment callback handling through ngrok
Transaction logging and MySQL database storage
Email notifications using PHPMailer
PDF receipt generation using mPDF

One of the most interesting parts of the project was using ngrok to expose localhost securely, allowing PayHere to communicate with local callback URLs such as notify_url, return_url, and cancel_url.

The project structure was designed to keep the workflow clean and modular, with separate files for checkout processing, notifications, verification, configuration, and database handling.

This implementation was a great hands-on experience in understanding how real-world payment systems work behind the scenes, from hash generation and callback verification to preventing duplicate transactions and securely handling payment confirmations.

Repository

GitHub Repository: https://github.com/NithilaLD/Building-a-Real-Time-Payment-Gateway-Integration-with-PHP-PayHere-ngrok-and-MySQL/

The repository includes the complete project resources, including the full implementation guide in PDF format, source code files for the payment gateway integration, and database setup scripts required to configure and run the application locally.

Tech Stack

Also Published On

This article is also available on the following platforms:

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

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
CODERLEGION: Read on CODERLEGION

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
CODERLEGION: Read on CODERLEGION