Case study · August 12, 2026 · 4 min read
Your Hospital's Next Board Report Depends on the System Behind It
Replacing fragile data pipelines with a recoverable, governed analytics platform

A board member wants to know why outpatient activity dipped this quarter. Finance needs to reconcile the year-end figures. An operational leader is trying to get a read on bed occupancy.
How confidently can your hospital answer?
For one Toronto specialty hospital, getting those answers used to mean pulling data from an EMR, scattered surveys, incident systems, and custom assessment apps. To make matters worse, the EMR’s database was built for running clinical workflows, not for aggregating years of historical activity.
While they had some reporting processes in place, the infrastructure wasn’t production-ready. Jobs routinely needed manual intervention. When something failed, figuring out why was a guessing game. Worst of all, if a server died or code was lost, there was no tested way to rebuild the analytics environment.
Starting point
- Manual and partially automated runs
- Failures with limited diagnostic detail
- Inconsistent code and environment versions
- No tested recovery procedure
Production platform
- Scheduled, versioned data pipelines
- Monitoring, logging, and failure alerts
- Controlled releases through CI/CD
- Backups and rehearsed restoration
Strategy first, pipelines second
Before writing any code, the hospital’s Head of Data and Strategy clearly defined what information the leadership team needed and the decisions it would support. Momo Analytics then turned that strategy into reality, building the architecture, logic, and operational controls to run it.
We started by nailing down the recurring metrics. Patient counts, service activity, occupancy, and fiscal reporting all needed an agreed-upon source, strict inclusion rules, and a clear owner. Precision is everything here: a patient seen in six different months counts as six monthly visits, but only one annual distinct patient. The business question dictates the math.
One governed path from source to report
We structured the new platform into distinct layers. This made data transformations traceable and gave every new source system a predictable route into the warehouse.
Here’s how the pipeline flows:
- Raw: We use Python jobs to ingest approved extracts from operational systems (EMR, HR, Finance) into a SQL Server database, retaining the raw records for auditing.
- Staging: Using dbt, we standardize identifiers, dates, and classifications.
- Shared Models: We build reusable SQL models for patients, visits, and assessments.
- Reporting Models: Finally, dbt generates the approved measures used for board and operational reporting.
- 01 RawRetained source records for processing and investigation Python
- 02 StagingStandardized identifiers, dates, statuses, and classifications dbt
- 03 Shared modelsReusable patients, visits, admissions, and assessments SQL Server
- 04 Reporting modelsApproved measures for board and operational reporting dbt
Every transformation is defined in code. Git tracks every change, and a CI/CD pipeline ensures safe releases into production.
Crucially, the pipeline handles late-arriving data. Recent outpatient activity is refreshed through a rolling window, staged, and updated inside a database transaction. Business rules, like adjusting occupancy calculations for leave-of-absence days, are baked directly into the models, where everyone can see them.
Why we chose Metabase
The hospital needed a reporting layer that fit their infrastructure and budget. We went with Metabase. The core edition is open-source and free, it supports LDAP authentication, and we could deploy it easily via Docker.
Running it in Docker makes the entire reporting application reproducible. Dev and prod run as isolated services with their own PostgreSQL databases and pinned application versions. We can test changes and rehearse disaster recovery without touching the live system.
Making disaster recovery an actual procedure
We asked a simple question: If we lost the code, the pipelines, and the reporting server today, could we bring analytics back online before the next board meeting?
We built a recovery design that covers every piece of the puzzle:
- Warehouse backups and retained source extracts.
- Version-controlled code for ingestion, transformation, and deployment.
- PostgreSQL backups of Metabase’s internal state (dashboards, users, permissions).
- Documented restore scripts.
We rehearse the restore procedure instead of assuming the backups will work.
Today, automated monitoring checks the pipelines and the Metabase health endpoint. If something fails, the alerts give us enough detail to know if a source feed is late or a Docker container went down.
The result
The hospital now has a governed, automated path from raw clinical data to executive reporting. Access is tightly controlled, failures are transparent, and the whole system has a tested recovery plan. It’s a platform built for reality.
Read the related case study: A Hospital Analytics Platform Built to Survive a System Failure.
Talk to Momo Analytics about your hospital’s data warehouse and reporting platform.