Forem: Esandu Hansaka Epa

How I Built the Admin Side of My Cricket Academy Management System

Esandu Hansaka Epa — Wed, 06 May 2026 02:53:05 +0000

How I Built the Admin Side of My Cricket Academy Management System

In the first post, I introduced the overall idea behind my Cricket Academy Management System and explained how the platform is built around multiple user roles.

In this part, I want to focus on the Admin role.

If the system is viewed as a complete academy ecosystem, then the admin side is the control center. This is the role that connects the entire operation together. From managing players and staff to handling sessions, finances, and academy-wide coordination, the admin role is responsible for keeping the platform organized and usable.

Why the Admin Role Matters

In a multi-role system, the admin is not just another user with more permissions.

The admin is the role that has visibility across the whole platform.

That means the admin side needs to do more than display data. It has to support decision-making, coordination, and operational control. While players, coaches, and trainers use the system for their own tasks, the admin uses it to manage the academy as a whole.

Because of that, I designed the admin area to bring several modules together in one place instead of treating them as isolated features.

Main Responsibilities of the Admin

The admin role in this project is responsible for several important areas:

managing staff members
managing player records
monitoring sessions and slot schedules
overseeing academy operations
viewing financial information
managing tournaments and related workflows
handling system-level coordination

The goal was to make the admin experience feel like a real operational dashboard rather than just a page full of forms.

Admin Dashboard Overview

The admin dashboard acts as the first point of control.

Instead of showing a simple welcome page, I designed it to give a quick overview of the academy’s current state. This includes high-level cards, visual summaries, and schedule-related visibility so the admin can immediately understand what is happening across the system.

The dashboard is designed to answer questions like:

How many staff members are active?
What sessions are coming up?
What tournament activity is visible?
What does the revenue summary look like?
What recent system activity has taken place?

This makes the dashboard useful as a monitoring space instead of just a navigation page.

Admin dashboard overview of academy operations

Staff Management

One important responsibility of the admin is managing staff.

This includes handling coaches, trainers, and other staff-related records. Since the academy depends heavily on role-based workflows, staff management is a critical part of the system. The admin needs to maintain the people who actually run sessions, guide players, and handle operational tasks.

The staff management section allows the admin to:

view staff records
manage different staff roles
maintain coach and trainer information
support the structure of the academy through organized staff data

This becomes especially important because other parts of the system depend on staff assignments and role-specific access.

Admin staff management interface

Player Management

The admin also needs full access to player information.

This includes viewing player records, managing academy data, and keeping the player side of the system organized. In a real academy setting, this is essential because player information connects with training, sessions, communication, and progress-related workflows.

The player management side of the system was built so the admin can keep the academy’s records clean and manageable while still supporting a larger role-based structure.

Admin player management page

Session and Slot Management

This is one of the most important parts of the project.

A major focus of this system is not just managing users, but managing sessions in a practical way. Since sessions are central to academy operations, the admin role needs strong control over how they are created, structured, and monitored.

That is why the admin side includes slot and session management views that help organize the academy timetable more clearly.

This part of the system supports things like:

session templates
structured scheduling
weekly timetables
calendar-based visibility
better coordination between academy roles

This is where the admin role becomes more than a record manager. It becomes the role that shapes how the academy actually runs on a day-to-day basis.

Session template and slot setup

Occurrences setup for academy session planning

Private coach request visibility for admin

Finance and Operational Monitoring

The admin role also includes a financial monitoring side.

Even though this is not the primary focus of the platform, it is still an important operational module. An admin needs some level of visibility into revenue-related information and payment-related activity because the academy does not only run on training schedules, it also runs on organized financial flows.

This part of the system gives the admin a way to monitor academy-level financial information while keeping it connected to the larger management structure.

Finance overview for the admin role

Tournaments as a Supporting Module

Although tournaments are part of the project, they are not the main focus of how I designed the admin side.

For this system, I treated tournaments as a supporting operational feature, while sessions remained the stronger core workflow. That decision helped keep the structure more grounded in everyday academy management rather than making the platform revolve around occasional events.

So while the admin can still handle tournament-related processes, the larger design emphasis remains on coordination, scheduling, and role-based management.

Technical Thinking Behind the Admin Role

One of the most interesting parts of building the admin role was that it required me to connect multiple modules in a meaningful way.

This was not just about giving one role more pages.

It was about making sure that:

the admin has broader visibility than other users
the admin workflow feels centralized
different modules still fit together logically
session-based operations remain easy to manage
the system supports realistic academy responsibilities

Since the project was built using pure PHP, HTML, CSS, and JavaScript without frameworks, building the admin side also helped me understand the structure of the application much more deeply. I had to think carefully about routing, role restrictions, module organization, and how data flows between different parts of the system.

Final Thoughts
The admin role became one of the most important parts of this project because it acts as the connection point between almost every major module.

It is where player management, staff management, sessions, finance, and academy coordination come together.

More importantly, it helped me move beyond the idea of building isolated pages and toward building a system where one role can manage real workflows across an entire platform.

In the next post, I’ll move on to the Coach role and show how the system changes when the focus shifts from academy-wide control to player-facing training responsibilities.

What Happens When You Build a Real Management System Without Any Frameworks

Esandu Hansaka Epa — Sat, 02 May 2026 15:37:00 +0000

Running a cricket academy is much more than registering players and scheduling a few events.

The real challenge is in the daily flow of operations.

Who manages player records? Who handles staff coordination? How are training sessions scheduled? How do coaches and trainers work with different responsibilities? How do players view their sessions, progress, and bookings?

That is the idea behind the project I built: a multi-role Cricket Academy Management System designed to support the real workflows of an academy through one connected platform.

This is not just a basic management website with a login screen and a few forms.

It is a role-based system where each user sees a different side of the academy.

Admin : Manages overall system
Coach : Players & training
Trainer : Fitness & structured sessions
Player : Sessions & schedules
Shop : Shop & Rentals

Why I built this

I wanted to build something that felt closer to a real-world software product.

Many projects stop at simple CRUD operations, but real systems are shaped by user responsibilities. A cricket academy is a good example of that — it has multiple people doing different kinds of work, and all of them depend on organized information.

In this project, I focused on building a system where:

each role has its own dashboard and workflow
sessions are a core operational feature
staff and players interact with the system differently
scheduling and management feel practical, not just visual
separate modules still work together as one product

The main idea behind the system

At the heart of the platform is the idea that an academy runs on coordination.

And one of the biggest parts of that coordination is sessions.

SESSIONS CONNECT EVERY PART OF THE SYSTEM

Admins manage the overall structure and scheduling
Coaches and trainers conduct and oversee sessions
Players depend on session visibility and participation
Scheduling affects both staff and academy resources

Because of that, session management becomes more than just showing a timetable. It becomes one of the main ways the system reflects real academy operations.

What this series covers

Each post will focus on one role: what that role does in the system, what features are available to them, how the interface supports their responsibilities, and how that role connects with the larger academy workflow.

What makes this project different

This project was designed with a role-first mindset.

Instead of only thinking about features page by page, I focused on questions like:

Who creates and manages sessions?
Who needs to see upcoming schedules?
Who is allowed to manage staff or players?
How should different dashboards behave for different users?
How do we keep the system useful for both management and daily operations?

That approach made the project more realistic and much more meaningful to build.

Technologies Behind the Project
This project was built completely using pure PHP, HTML, CSS, and JavaScript without relying on any frameworks. I wanted to focus on understanding the core logic behind a multi-role system by building the structure, routing, backend handling, and frontend behavior more directly.

Pure PHP for backend development
MySQL for database management
HTML, CSS, and JavaScript for the user interface
MVC architecture for clean project organization
Chart.js for analytics and dashboard charts
Email integration for notifications and account-related communication
PayHere for online payment processing
XAMPP for local development and testing

What you can expect from this series

In the next five posts, I'll break the system down role by role and show how each user interacts with it.

This series will be useful if you are interested in:

multi-role application design
role-based dashboards
session and schedule management systems
practical web application structure
building software that reflects real workflows
full scratch web dev

A management system is not only about storing data. It is about supporting people in their responsibilities and helping different parts of an organization work together smoothly. For this system, sessions became one of the strongest examples of that idea.

In the next post, I'll start with the Admin role and show how the central management side of the academy works.

If you are building something similar or have questions about multi-role system design, drop a comment below.