PHP-Based Platform for Infrastructure Monitoring & Performance Analytics

As a PHP Software Engineer at La Banque Postale, I contributed to the development of an enterprise monitoring and performance analytics platform used to monitor IT infrastructure across Groupe La Poste.

Working within an Agile team of 11 developers, we built a web application allowing IT operations teams to monitor infrastructure performance, analyze historical metrics, and identify potential issues through interactive dashboards.

The platform collected technical information from servers distributed across multiple isolated network zones, including CPU usage, memory consumption, storage utilization, filesystem activity, and process statistics.

I worked on both the PHP/Angular application and the distributed data collection infrastructure, combining web development with infrastructure automation and system integration.

The solution relied on satellite collectors, automated task scheduling, centralized log storage, Elasticsearch clusters, and a custom monitoring interface built with PHP, Angular, and Highcharts.

Project Context - Building a Centralized Infrastructure Monitoring Platform

At Groupe La Poste, IT production was managed by multiple teams responsible for different applications and infrastructure environments. Our development team worked closely with these operational stakeholders to understand their monitoring requirements and deliver tools adapted to their daily activities.

One of our main products was a monitoring and performance analytics platform providing application-centric infrastructure visibility.

Instead of monitoring servers independently, users could select an application and access dashboards displaying technical metrics for all its associated servers.

The application provided:

• CPU and memory usage trends.
• Storage and filesystem utilization.
• Running process counts and process activity.
• Historical performance analysis.
• Interactive graph comparisons.
• Configurable alerts based on metric thresholds.

We developed the application using PHP, a custom framework based on CakePHP, Angular, and Highcharts for interactive data visualization.

Developing a Distributed Data Collection Architecture

One of the main technical challenges was collecting metrics from servers located across different network security zones. Direct connectivity between the central application and every monitored server wasn't always possible.

To address this, we deployed satellite collector servers within the different network zones. These collectors were responsible for executing monitoring processes on target systems and gathering performance information.

We used several technologies:

• nmon: To collect system performance statistics.
• Bash and Perl: To execute custom monitoring scripts and process collected data.
• Custom Task Scheduler: To orchestrate collection jobs and execute them at configurable frequencies.
• Satellite Collectors: To reach servers across different network zones.

The platform allowed users to configure collection frequencies according to their monitoring requirements.

Centralizing Logs and Processing Performance Metrics

The collection architecture also required an efficient way to store and process large volumes of technical data.

We implemented a centralized data processing infrastructure combining:

• Dedicated Log Storage Servers: High-capacity systems used to retain collected monitoring files.
• Elasticsearch Clusters: Providing indexed storage and efficient searching across collected logs.
• Application Database: Storing extracted performance metrics for dashboard visualization.

During log processing, relevant technical statistics were extracted and inserted into the application database. This allowed the frontend to retrieve structured historical metrics and generate interactive charts without repeatedly processing raw monitoring files.

Users could then investigate performance trends, compare different time periods, and identify abnormal resource consumption.

4. Agile Development with IT Operations Teams

The platform was developed by a team of 11 software engineers working with a Kanban methodology.

We collaborated closely with the project's business representative and IT operations stakeholders to understand their needs, prioritize improvements, and deliver new monitoring capabilities.

This experience exposed me to both enterprise web application development and the operational challenges of collecting, processing, and analyzing infrastructure data at scale.

• Full-Stack Development: Contributed to the PHP backend and Angular frontend, developing monitoring features and interactive dashboards using a custom CakePHP-based framework and Highcharts.
• Monitoring & Data Collection: Worked on the distributed collection infrastructure using nmon, Bash, Perl, and satellite collector servers to gather technical metrics across isolated network environments.
• Data Processing & Integration: Contributed to the collection and processing workflows connecting monitoring logs, centralized storage, Elasticsearch, and the application database.

• Centralized monitoring across multiple network security zones: Enabled infrastructure data collection through distributed satellite servers, providing a unified view of application performance.
• Delivered application-level monitoring across multiple metric categories: Provided visibility into CPU, memory, storage, filesystems, process activity, and other system performance indicators.
• Enabled advanced performance analysis: Delivered configurable monitoring frequencies, historical graph comparisons, and threshold-based alerts through interactive Highcharts dashboards.
• Established a centralized data collection and analysis architecture: Combined nmon, Bash/Perl scripts, automated scheduling, high-capacity log storage, and Elasticsearch to support structured monitoring and log investigation.