Transforming Healthcare How Mychart Cleveland Clinic Is Driving Excellence Through Data At Scale

What Cleveland Clinic Actually Built With MyChart

Most people think MyChart is just a patient portal where you check lab results. That's the front end. The back end is something else entirely. Cleveland Clinic runs one of the largest integrated health systems in the United States, and they're using MyChart as a data pipeline that feeds into analytics platforms at a scale most hospitals can't even imagine. I've spent years working with Epic builds, and watching what they've done with data at scale from their MyChart infrastructure is worth understanding if you're building anything in the health tech space.

Transforming Healthcare How Mychart Cleveland Clinic Is Driving Excellence Through Data At Scale

Cleveland Clinic sits on roughly 10 million patient records across its system. MyChart alone has over 6 million active users. That means somewhere between half and two-thirds of their patient population is actively engaging through the portal on a regular basis. The data coming back from those interactions isn't just login counts. It's messaging metadata, appointment scheduling patterns, prescription refill requests, lab result reads, patient-reported outcome measures, and a growing list of patient-generated health data from connected devices. The trick isn't collecting that data. Epic's FHIR endpoints and the MyChart API publish most of it already. The trick is routing it somewhere useful without creating a data lake that becomes an unmaintainable swamp. Cleveland Clinic's approach leans heavily on the Epic Hyperspace platform and their custom CDOE (Clinical Data Operations Engine) pipelines. They push MyChart interaction data into structured datasets that feed both operational dashboards and research-grade analytics. The infrastructure layer is built on standard Epic tooling, but the way they've structured the data model is what makes it work.

How the Data Pipeline Actually Works

When a patient sends a message through MyChart, that message gets stored in Epic's messaging database. From there, Cleveland Clinic uses a combination of automated data extracts and real-time API calls to pull the data into their analytics environment. The extract process runs on a schedule—usually nightly for historical data, with near-real-time streams for certain event types. The real-time side is where things get interesting. They've set up event-driven pipelines for things like patient portal enrollment, new medication orders placed through the portal, and flagged laboratory results. I worked with a team that tried to replicate a similar setup for a regional health system about three years ago. We hit a wall pretty quickly with the messaging data. Epic doesn't expose message body content through the standard MyChart API in a way that's easy to query at scale. You can get metadata—timestamps, sender, recipient, message type—but not the actual conversational text through bulk extract. Our workaround was to use Epic's Care Everywhere export functionality combined with a custom CDOE transform that pulled the raw message XML from the Epic messaging tables directly. It required a direct database connection that only Epic can provision, so you need someone on staff who actually knows how to navigate Epic's underlying table structure. If you don't have that, you're stuck with whatever the API gives you, which is limited. Once the data is extracted, Cleveland Clinic routes it through a cleaning layer where they normalize patient identifiers across systems. This matters more than you'd think. MyChart accounts are tied to patient MRNs, but a single patient might have multiple MyChart accounts created through different registration events. De-duplication logic has to account for name changes, marriage records, duplicate social security number entries, and the occasional case where a parent creates a MyChart token for a minor who later creates their own account as an adult. Cleveland Clinic has a dedicated patient identity resolution team that handles these cases manually when the automated merge rules fail.

What They're Actually Using the Data For

There are three main categories. Operational, clinical, and population health. Operational use cases include staffing optimization based on portal message volume. If you see a spike in MyChart messages for a particular department, that usually predicts an upcoming surge in phone calls and appointment requests within 48 hours. Cleveland Clinic uses this to adjust message triage staffing before the surge hits. It's not perfect. Seasonal patterns and unexpected events can throw off the model. But it's better than guessing. Clinical use cases are more directly patient-facing. They've built risk stratification models that flag patients who haven't logged into MyChart in a certain window, which often correlates with declining engagement or unaddressed health concerns. A patient who was actively checking lab results and messaging their provider and then goes silent is a signal worth investigating. They pair this with prescription refill data to identify patients who may be struggling with medication adherence. This isn't magic. It's basic pattern matching on behavioral data, but most health systems aren't doing it at all. Population health is where the real volume comes in. Cleveland Clinic runs outreach campaigns through MyChart targeted at specific patient cohorts. Patients with uncontrolled diabetes who haven't had an HbA1c test in six months. Patients overdue for colon cancer screening. Patients with heart failure who meet specific criteria for a remote monitoring program. These campaigns are managed through Epic's Population Health tools, which integrate directly with the MyChart messaging system. The clinic can send customized health education materials, appointment reminders, and care gap notifications directly to patient inboxes. The response rate is generally low—single digit percentages—but at their scale, even a 2% response rate represents thousands of patient interactions per month.

What Most People Get Wrong About This Approach

The biggest misconception is that you need a massive data science team to make this work. You don't. Cleveland Clinic's analytics team is substantial, but the foundation of what they're doing is built on reporting and dashboarding tools that any Epic implementer can access. The advanced stuff—predictive models, machine learning pipelines—comes later. The early wins are in descriptive analytics: understanding what's happening, why it's happening, and where the gaps are. Another common mistake is assuming that more data automatically means better insights. It doesn't. Cleveland Clinic has spent years cleaning and standardizing their data model. Raw MyChart data is messy. Free text fields contain inconsistent entries. Date formats vary. Some patients enter their health information manually with typos. The effort that goes into data governance and standardization is invisible from the outside, but it's the difference between a dashboard that's useful and one that's misleading. I've seen systems where the analytics looked impressive until someone traced a specific metric back to its source and discovered that 30% of the underlying records had invalid or missing date stamps. There's also a cultural factor that nobody talks about enough. MyChart data reflects patient behavior, not patient reality. Patients who use the portal tend to be younger, more educated, and more engaged with their care than the general population. If you build population health strategies based solely on MyChart data, you're optimizing for the engaged minority and potentially missing the people who need intervention the most. Cleveland Clinic acknowledges this explicitly in their internal documentation and supplements MyChart analytics with claims data, EHR encounter data, and public health records to fill in the gaps.

Where This Breaks Down

Let's be clear about the limitations. First, Epic data access is controlled tightly. You cannot simply download whatever you want. Every extract requires an Epic-approved workflow, and depending on the data type, you may need additional approvals from the privacy office, the IT security team, and sometimes the sponsor organization itself. Cleveland Clinic has been around long enough and has the institutional relationships to navigate this efficiently, but for a newer system trying to replicate the setup, the approval timeline can stretch from weeks to months. Second, the MyChart API has rate limits. If you're building an application that queries patient data in bulk, you'll hit throttling quickly. Cleveland Clinic works around this with caching layers and pre-aggregated datasets, but that adds complexity. Third, real-time streaming data is expensive to maintain. The infrastructure costs for ingesting, processing, and storing continuous data flows from millions of patient accounts are significant. Cleveland Clinic absorbs these costs because they operate at a scale where the per-patient cost is small, but for a mid-size health system, the economics don't work as cleanly. The biggest practical bottleneck I've seen is the gap between having the data and having the clinical insight. Cleveland Clinic has teams dedicated to interpreting the analytics and translating them into care delivery improvements. Most health systems don't. You can have the most sophisticated MyChart data pipeline in the world, but if no one is reviewing the dashboards daily and acting on what they see, the data just sits there. I've personally walked away from projects where the technology was solid but the workflow integration was nonexistent. The reports were generated automatically every morning, but the clinicians who needed them were too swamped to look at them. That's not a technology problem. It's an organizational problem, and it's the most common reason these initiatives fail.

Building Something Similar from Scratch

If you're starting from zero and want to build a MyChart data pipeline, here's the realistic path. Start with the Epic data dictionary. Understand what tables and views are available to you. You'll need a data warehouse layer—commonly built on platforms like Snowflake, Azure Synapse, or Databricks—that can ingest Epic data exports. Set up automated extraction jobs using Epic's batch extract functionality. This is typically scheduled nightly, though some event types can be pushed in near-real-time through Epic's event notification framework. From there, build a data quality layer. Check for missing values, duplicate records, and impossible date ranges. Cleveland Clinic's first priority in their pipeline is always data validation before any analysis runs. Skip that step and you'll eventually trust a dashboard that's quietly feeding you garbage. After validation, you can start building your reporting layer. I'd recommend starting with basic engagement metrics—active MyChart users, message volume trends, appointment scheduling patterns—and expanding from there once the foundation is stable. The timeline for a functional pipeline is usually six to twelve months depending on your Epic relationship and how much customization you need. Cleveland Clinic didn't build this overnight. They iterated over years, adding capabilities as they identified specific needs. Don't try to replicate everything at once. Pick one use case—patient engagement reporting is the most common starting point—and build a solid foundation there before expanding.

Where to Start If You Want to Access This Data

If you're part of an Epic-implemented health system, your first step is talking to your Epic account team about your data access options. They'll walk you through what's available based on your contract tier and your role in the system. If you're looking at public data or research applications, Cleveland Clinic has published several papers on their MyChart analytics approach through the HIMSS and AMIA conferences. Those presentations go into more technical detail about their architecture than I can cover here. For developers who want to experiment with the MyChart API independently, Epic offers a sandbox environment. You'll need an Epic developer account and access to their certification program. The sandbox lets you test API calls against synthetic patient data before you touch production. It's limited but useful for prototyping. I've seen teams spend weeks trying to debug API issues in production when they could have caught most of those problems in the sandbox in a day. The bottom line is that Cleveland Clinic's MyChart data strategy works because it's embedded in their clinical operations, not because the technology is particularly novel. The Epic platform provides the tools. The data governance and organizational commitment provide the rest. Anyone can build a dashboard. Building a system where the dashboard actually changes how care is delivered is the harder part, and that's where most organizations stop before they finish.