Case Study: Modernising Higher Education Data Operations

Bridging Student Records and Learning Systems with Azure & Serverless Architecture

Role: Integration Developer (Contract)

Client: University of London

Timeline: Sep 2025 – Present

Core Stack: Azure, Python, React, Next.js, SITS:Vision, Canvas

1. Executive Summary

Higher education institutions often struggle with “data silos”—where critical student information is trapped in legacy record systems, unable to flow freely to modern learning platforms.

This project focused on breaking down those silos. I architected and delivered a robust integration between SITS:Vision (the central student record system) and Canvas LMS using a serverless Microsoft Azure architecture. Beyond the data pipe, I developed a custom “Control Tower” dashboard to give the operations team full visibility and governance over the system, reducing error resolution time and eliminating manual data handling.

2. The Challenge

The University required a seamless flow of student enrolment data into their Learning Management System (LMS). The existing landscape presented significant operational hurdles:

• Data Latency: Student enrolments were not reflecting in Canvas in real-time, affecting the student onboarding experience.

• Black Box Middleware: When data transfers failed, the operations team had no visibility into why. They lacked tools to query the message queues or inspect payloads without technical intervention.

• Fragmented Governance: Error logs were scattered, making it difficult to spot trends or assign fixes to the right contractor teams.

3. The Solution

Phase 1: The Integration Core

I designed an event-driven architecture to decouple the two massive systems. Using Azure Service Bus, we ensured that if one system went down for maintenance, data would simply queue up rather than fail.

• Ingestion: Python-based Azure Functions to capture changes from SITS:Vision.

• Processing: Serverless microservices to transform complex student data schemas into Canvas-compliant JSON.

• Reliability: Implemented Dead Letter Queues (DLQ) to catch “poison messages” (corrupted data) so they wouldn’t block the rest of the pipeline.

Phase 2: The “Control Tower” Dashboard

To solve the visibility problem, I built a custom full-stack administrative tool using React and Next.js. This was not just a viewer; it was an operational tool.

• Real-time Querying: Enabled staff to search Azure Service Bus queues instantly to find specific student records.

• DLQ Management: Built “Replay” functionality, allowing admins to fix data errors and re-inject messages into the queue with a single click.

• Container Visibility: Provided a window into the middleware containers to monitor health and performance.

Phase 3: Unified Governance & Logging

A system is only as good as its error handling. I designed a centralised logging framework that was adopted by multiple external contractor teams to ensure consistency.

• Router Pattern: All exceptions were routed through a central hub.

• ServiceNow Integration: Critical technical failures automatically raised tickets in ServiceNow for immediate triage.

• Audit Trail: Low-level logs were sent to Azure Log Analytics and Cosmos DB for long-term retention and pattern analysis.

4. Key Results

• Real-Time Sync: Reduced data propagation time between SITS and Canvas from hours to near-real-time.

• Operational Autonomy: The custom dashboard empowered non-technical support staff to investigate data issues without escalating to developers.

• Standardised Quality: The new error logging framework became the gold standard, adopted by two separate vendor teams for its clarity and robustness.

5. Technology Stack