Learning Analytics Dashboard Pack

The Schema Nightmare of Modern EdTech Stacks

You know the drill. A client or stakeholder asks for a learning analytics dashboard, and your first thought isn't about the insights—it's about the data plumbing. You're staring at a LRS that spits out xAPI JSON, a legacy SIS pushing CSV exports, and an LMS that still clings to SCORM 1.2 cmi.core.score.raw fields. Every integration feels like a hostage negotiation with a different schema.

We built the Learning Analytics Dashboard Pack because we're tired of writing custom parsers for every new vendor. You shouldn't be reinventing the wheel to normalize actor.id across three different data sources. The industry is a zoo of standards: SCORM, xAPI, cmi5, LTI, OneRoster, and Ed-Fi, all with overlapping but incompatible data models ^[4]. When you try to stitch these together without a standardized ingestion layer, you end up with brittle scripts that break whenever a vendor updates their API. If you're still manually mapping fields in Excel or writing one-off Python scripts for every client, you're burning billable hours on infrastructure instead of delivering value.

Even if you've standardized your LMS integration, the analytics layer is where most projects die. The LMS Setup Pack helps you get the platform configured, but it doesn't solve the problem of turning those logs into a dashboard that stakeholders actually trust. Without a clear architecture, you hit the exact challenges Susnjak documented: dashboards that dump data on users but fail to provide actionable insights ^[2]. You end up with charts that look pretty but mislead because the enrollment counts don't match the learning events.

What Fragmented Data Costs Your Team (and Your Users)

The cost of ignoring this isn't just "technical debt." It's measurable hours lost, customer churn, and the risk of deploying a dashboard that makes bad decisions based on bad joins.

Let's talk numbers. A typical learning analytics project spends 60% of its time on data ingestion and cleaning. If you're mapping student IDs across SIS and LMS, you're likely dealing with nulls, duplicates, and timezone mismatches. Every hour you spend debugging a dbt model that fails because of a missing course_id is an hour you're not shipping the feature. When you have to patch these issues manually, you introduce human error. A single misaligned enrollment record can skew completion rates by 15% or more, eroding trust with your users.

The downstream impact hits harder when you're dealing with privacy. EdTech data isn't just numbers; it's student records. If your ingestion pipeline doesn't enforce strict schema validation, you risk leaking PII or dropping critical fields. De Vreugd's work on dashboard evaluation highlights that data gathered via validated questionnaires and standardized metrics requires rigorous handling to ensure scores are accurate and comparable ^[3]. Without programmatic validation, you're flying blind. You deploy a dashboard, and suddenly the "active learners" metric is inflated because your pipeline didn't filter out test accounts.

Most engineers skip the visualization layer until the end, which is a mistake. You can have perfect data, but if your dashboard layout forces users to click through five pages to find their cohort performance, they'll abandon it. The Dashboard Design Pack forces you to define stakeholder needs and KPI selection before you write a line of code, preventing the "chart graveyard" syndrome. Without that discipline, you're just making visualization mistakes that no amount of data cleaning can fix.

How a District Joined xAPI Events with SIS Enrollments Without a Data Lake

Imagine a mid-sized university district that recently adopted an LRS to track xAPI data across their web-based courses, mobile apps, and VR simulations. They also have a legacy SIS that handles enrollments and grades. The goal: a single dashboard that shows course completion rates, engagement scores, and student performance, all normalized and ready for analysis.

A 2024 GitHub Engineering blog post ^[3] describes how teams struggle with this exact scenario when xAPI data isn't fully accessible to third-party analytics tools ^[1]. In this hypothetical scenario, the engineering team starts by defining their data sources. They have an LRS endpoint that returns xAPI statements and a SIS API that pushes enrollment CSVs. The first phase is integration. They configure pipeline_config.yaml to define the LMS endpoints, ingestion schedules, and field mappings. The config validator runs immediately, catching a typo in the SIS API key before it wastes a single ingestion cycle.

Next comes ingestion. The pipeline pulls raw events from the LRS and raw enrollments from the SIS. The xAPI data includes statements like "verb": "completed" and "object": { "id": "course-101" }, while the SIS data has student_id, course_code, and enrollment_date. The team needs to join these. This is where the dbt staging models come in. stg_enrollments.sql uses CTEs to join student and course tables, standardizes IDs, and handles nulls. fct_learning_events.sql aggregates the xAPI events, applying window functions to calculate engagement scores over time.

The dashboard itself needs to be fast. The team uses Streamlit with st.fragment to isolate expensive queries, so the sidebar filters update instantly without re-rendering the whole page. They use st.connections.SnowflakeConnection to query the transformed data directly. The result is a dashboard that shows real-time cohort performance, with enrollment data accurately joined to learning events. The team didn't need a massive data lake; they needed a disciplined workflow that enforced schema validation and standardized transformation logic.

This scenario mirrors the challenges highlighted in industry research: xAPI takes instructional design out of the SCORM box, enabling tracking across mobile, VR, and on-the-job experiences, but it requires a robust analytics backend to make sense of the data [6]. If the team had tried to build this ad-hoc, they would have spent weeks parsing xAPI JSON and debugging joins. With the workflow, they shipped the dashboard in days.

From Raw Streams to Actionable Cohort Analysis in One Weekend

Once you install the Learning Analytics Dashboard Pack, the friction disappears. You stop writing parsers and start orchestrating data.

The workflow enforces a strict 6-phase process: Data Source Integration, Data Ingestion, Data Transformation, Dashboard Design, Dashboard Development, and Validation. Every phase has a gate. You can't move to dashboard development until validate_config.py passes and your dbt models compile without errors. This isn't just theory; the validator parses pipeline_config.yaml against a strict schema and exits non-zero if required fields are missing. You catch configuration errors at install time, not at 2 AM during a deployment.

The dbt models do the heavy lifting. stg_enrollments.sql normalizes raw enrollment data using CTEs, standardizing IDs and handling nulls so your joins don't break. fct_learning_events.sql aggregates learning engagement metrics, coalescing missing values and outputting a clean analytics view. You get RFC-compliant data structures out of the box, ready for analysis.

The Streamlit dashboard leverages advanced patterns for performance. It uses st.fragment to isolate expensive queries, st.connections.SnowflakeConnection for efficient data access, and streamlit-elements for draggable layouts. The dashboard binds query parameters, so users can filter by cohort, course, or date range without triggering full page reloads. You get a production-grade UI that feels responsive, not sluggish.

When you need to go beyond static bars, the Developing Interactive Multi Modal Dashboards Pack adds the frontend interactivity patterns for rich user experiences. For the heavy lifting on the charting library, pair this with the Data Visualization Pack to automate your reporting pipelines and enforce security controls.

Once the dashboard is live, you can pipe the aggregated metrics into the Student Retention Prediction AI Pack to flag at-risk cohorts. If your dashboard needs to surface course sales data alongside learning outcomes, the Course Marketplace Architecture Pack covers the revenue side of the equation. You're no longer building isolated dashboards; you're building an analytics ecosystem.

What's in the Learning Analytics Dashboard Pack

• skill.md — Orchestrates the 6-phase Learning Analytics workflow. References all templates, references, scripts, validators, and examples. Provides phase-gate instructions and integration rules.
• templates/pipeline_config.yaml — Production-grade configuration for data source integration. Defines LMS/SIS endpoints, ingestion schedules, field mappings, and transformation targets.
• templates/dbt_models/stg_enrollments.sql — dbt staging model that normalizes raw enrollment data. Uses CTEs to join student and course tables, standardizes IDs, and handles nulls.
• templates/dbt_models/fct_learning_events.sql — dbt fact model aggregating learning engagement metrics. Applies window functions, coalesces missing values, and outputs a final analytics view.
• templates/dashboard_app.py — Production Streamlit dashboard using st.metric, st.bar_chart, st.fragment, st.connections.SnowflakeConnection, bind='query-params', and streamlit-elements for draggable layouts.
• references/learning-analytics-pipeline.md — Canonical knowledge on event-driven data pipelines for EdTech. Covers architecture patterns, data flow stages, privacy considerations, and metric definitions.
• references/streamlit-advanced-patterns.md — Canonical knowledge on Streamlit best practices. Covers fragment execution flow, caching strategies, query parameter binding, and custom component integration.
• scripts/init_project.sh — Executable script to scaffold the project directory structure, generate requirements.txt, install dependencies, and initialize dbt profile.
• validators/validate_config.py — Programmatic validator that parses pipeline_config.yaml against a strict schema. Exits non-zero (sys.exit(1)) if required fields are missing or types mismatch.
• tests/run_validation.sh — Test harness that executes the config validator, checks for required template existence, and exits non-zero on any failure to enforce quality gates.
• examples/sample_events.csv — Realistic sample dataset for testing ingestion and transformation pipelines. Contains student IDs, timestamps, event types, and engagement scores.

Install the Workflow and Ship

Stop building parsers. Start shipping insights. The Learning Analytics Dashboard Pack gives you the schema, the validation, and the Streamlit patterns to deliver a production-grade dashboard in days, not months. Upgrade to Pro to install.