Skip to content
<-- All Projects

Platform Health Dashboard

Observability Layer · Distributed Monitoring · Drupal Ecosystem Tooling

Implemented a lightweight observability layer to monitor and surface platform health across over 60 distributed Drupal applications, reducing site-level diagnostics from hours to minutes and enabling proactive upgrade planning.

Role:
Developer
Employer:
IfThen
Client:
Internal
Team:
1
Industry:
Digital Services
Timeline:
2 months (2023)

Impact

  • Reduced time to assess individual site health, stack versions and build information from ~1 hour to a few minutes
  • Provided centralized visibility across all Drupal sites spanning multiple platform versions
  • Enabled faster upgrade planning through consistent environment and platform diagnostics
  • Improved team awareness of platform state and deployment recency across environments
  • Adopted as a routine operational tool for engineering workflows and system validation

My Role

  • Sole developer and product owner
  • Designed and implemented full-stack architecture using Next.js and TypeScript
  • Developed and distributed a shared Drupal module exposing standardized health endpoints
  • Defined cross-system contracts for platform diagnostics and monitoring
  • Implemented polling, normalization, and failure-handling strategies
  • Deployed and maintained the application on Vercel as an internal tool

Technical Architecture

Implemented as a thin full-stack observability layer combining a centralized monitoring application with distributed health endpoints across Drupal systems.

System Overview

  • Next.js application serving both dashboard UI and server-side monitoring routes
  • Server-side proxy handling outbound health checks, timeouts, and response normalization
  • Custom polling layer orchestrating initial checks and interval-based refresh
  • Distributed Drupal module exposing health endpoints with structured platform metadata
  • Health responses combining uptime validation with environment and deployment diagnostics

Architectural Decisions

  • Adopted a server-side proxy pattern to centralize monitoring logic and eliminate browser CORS constraints
  • Designed a producer–consumer observability model with Drupal systems exposing pulse data and the dashboard consuming and normalizing results
  • Standardized platform diagnostics through a shared Drupal module deployed across all monitored systems
  • Separated polling, UI, and network concerns to support maintainability and future enhancement
  • Used a config-driven approach to manage monitored sites without introducing unnecessary infrastructure

Stack

Frontend

Next.jsReactTypeScriptTailwind CSS

Backend

Custom Drupal ModuleREST APINext.js Route Handlers

Infrastructure

VercelAcquiaPantheonRepman

Context

The development team managed a large portfolio of Drupal sites spanning multiple versions, hosting platforms, and deployment timelines. Assessing the operational state of an individual site required manual inspection of uptime, platform versions, deployment metadata, and scheduled task execution, often taking up to an hour per site.

There was no standardized mechanism for exposing platform-level status, making cross-site comparison and upgrade planning inefficient.

The objective was to establish a consistent, low-friction way to surface both uptime and platform state across all systems. The resulting solution introduced a distributed observability model that allowed the development team to quickly assess and respond to typical maintenance requirements.