"71% passed"
A number with no participant behind it. You cannot open it to see who the other 29% are, or follow up.
How to build a program dashboard that runs one program live — a step-by-step method, 7 examples, and program dashboard vs program management dashboard.
Sopact reads every attendance record, survey, and mid-cycle reflection the moment it arrives — and joins it to the participant behind the tile, so the dashboard shows who is slipping while the cohort is still running. A dashboard that refreshes nightly surfaces Tuesday's problem on Wednesday — after a participant has missed two more sessions. This page is the step-by-step method, for the program managers and directors who run the program from the dashboard, not from a quarterly report.
By Unmesh Sheth · Founder & CEO, Sopact · Updated May 25, 2026
A program dashboard is the live view of whether one program is producing the change it was designed to produce. It carries three layers — operational health on top, outcomes underneath, the AI-themed reason from open-ended reflections on the side. The test that matters: every tile drills to the participant behind it, and the screen reflects current state — not a snapshot from last quarter.
A number with no participant behind it. You cannot open it to see who the other 29% are, or follow up.
Numbers in motion. But Tuesday's drop-off surfaces Wednesday, and the reason sits unread in a free-text field.
The team runs the program from this one.
Most program dashboards fail the same way: they become a reporting artifact nobody opens, because the action happens somewhere else — in a spreadsheet, in Slack, in the program manager's head. Four failure modes account for nearly all of it.
A tile shows 71%. You cannot open it to see who the other 29% are, which session they last attended, or who to call this afternoon.
The dashboard refreshes overnight. Tuesday's barrier surfaces Wednesday morning — after a participant has missed two more sessions.
Mid-cycle reflections hold the why behind every number. With no AI layer they are a manual quote-pull — so the dashboard shows the number and never the reason.
The dashboard is rebuilt from exports each reporting cycle. It lags the program by weeks, so the team falls back to the spreadsheet and the dashboard goes unopened.
A program dashboard fails when a tile cannot be opened to the participant behind it, and when it reports on a schedule instead of reading data as it arrives. Both are upstream of the chart — no visualization tool fixes either.
The fix is not a prettier tile. It is a change in when the dashboard reads its data, and what it does with it once it has. Sopact builds program dashboards on three principles.
An attendance dip and the mid-cycle reflection that explains it are themed, scored, and joined to the participant record the morning they happen — not held for a nightly batch. The signal and its reason land together.
Every participant keeps one Persistent Contact ID across intake, mid-cycle, and exit. Every tile drills to the same record — so an outcome is a trajectory, and a number is always one click from the person behind it.
Operational health on top, outcomes underneath, the AI-themed reason on the side — with alerts that fire on attendance and dosage thresholds. The dashboard becomes the operating system for delivery, not a reporting artifact.
A nightly batch tells the program manager what happened yesterday. An immediate, continuous, learning dashboard flags the three participants who missed last session before the next one starts — while there is still time to reschedule.
Before any tile, two questions decide whether a program dashboard can be run from: where the data comes from, and whether the system knows what each field means. This is the layer Sopact owns — sources on the left, a live dashboard on the right.
The data dictionary defines what counts as at risk and sets the alert thresholds. Every tile drills back to the participant record — governed, not guessed.
Every tile opens back to the participant record it came from — traceable to source.
A program dashboard is mostly a live view of the program's own delivery and outcomes. Sopact Sense collects intake, attendance, surveys, and mid-cycle reflections clean at source — one record per participant, qualitative and quantitative on the same row. Lead with primary data: it is what makes every tile drill to a participant, and every alert fire on time.
A learning management system or attendance system may already hold session data, and a funder may require a set framework. Integrate secondary data when those systems hold what you would otherwise re-collect. The data dictionary maps each field to the participant record, so the live view reads one dataset.
Sopact's layer is the combination — qualitative data, quantitative data, and the data dictionary that defines at-risk thresholds and governs the join. It is what lets a tile open to the participant behind it — and an alert fire the morning a participant slips, not at cohort close.
Here is the build, in the order Sopact runs it — six steps from the program manager's weekly decisions to a dashboard that refreshes itself and fires alerts on its own.
Start from the standup: who to follow up with, which session to fix, which site is slipping. "Show me who missed last session" beats "build a program dashboard." The weekly decisions decide which tiles the dashboard needs and which alerts it fires.
Turn the program theory into a logic model, then define every field — what counts as at risk, the attendance and dosage thresholds, the survey scale. Both are signed before collection starts. The thresholds are what let the dashboard alert instead of just display.
Run intake, attendance, surveys, and mid-cycle reflections through Sopact Sense. Each participant gets one Persistent Contact ID at intake; every later touchpoint links to it; duplicates and typos are caught in the form, not at cohort close.
Connect a learning management or attendance system, and prior-cohort data, through the data dictionary. Each field maps to the participant record, so the dashboard reads one dataset — no nightly export, no re-keying.
Sopact reads every response and reflection the moment it lands — theming the narratives, scoring outcomes, firing alerts on the thresholds. The view is then assembled in plain language — operational on top, outcomes underneath. This is the step an AI build tool finishes in minutes.
The dashboard updates as records update. Role-based views give program staff participant detail, leadership the cross-cohort trend, funders the reporting layer — all filtered from one source, no separate build per audience.
The nightly-batch lag is gone — the dashboard is live, and the funder view is a filter, not a build.
No separate BI build per reporting cycle — staff hours move from rebuilding the report to running the program.
The at-risk participant is flagged while there is still time to act — not named in the post-mortem.
The method produces a dashboard the team runs the program from — operational health on top, outcomes underneath, the AI-themed reason on the side. Below is a live view for a sample workforce program. Sample data, illustrative.
| Cohort | Enrolled | Completion | Credential pass | 90-day placement |
|---|---|---|---|---|
| Cohort 01 | 102 | 79% | 64% | 58% |
| Cohort 02 | 115 | 84% | 71% | 64% |
| Cohort 03 | 109 | active | — | — |
Week 8 attendance at 79% and "childcare" rising in the reflections are not two findings. They are one finding — the number and its reason — on one screen. The alert fired Monday. The cohort is still running, so the team can still act.
Seven views cover most of what a program manager needs to run one program. Each is a filtered view of the same participant record — and each names its sources and the risk it is built to catch.
The dashboard view itself — the tiles, the layout, the layered layout — is no longer the hard part. Claude, Google's analytics stack, Microsoft Power BI, Tableau, and Looker all turn clean, well-defined data into a working dashboard in an afternoon.
So the value is not in the tile-building. Tableau, Power BI, and Looker are strong visualization tools, but they sit downstream of a data store that has to be populated first — they render a dashboard once the work is done; they do not produce the participant record. Point an AI build tool at a monthly spreadsheet export and it builds a fast, confident, stale dashboard. Point the same tool at the layer Sopact maintains — the live participant record, qualitative and quantitative on one row, the at-risk thresholds defined — and it builds a dashboard the team runs the program from.
The analysis got easy. The participant record did not. That is the layer to own.
A monthly spreadsheet is a snapshot. A PMO dashboard — the project-management sense of "program management dashboard" — tracks tasks, milestones, and budget, not participant change. A BI dashboard renders whatever it is handed. A working program dashboard, in the impact sense, runs one program live off the participant record.
| Capability | Spreadsheet (monthly) | PMO dashboard (Asana, Smartsheet) | BI dashboard (Power BI, Tableau) | Sopact |
|---|---|---|---|---|
| Tracks participant change, not tasks | Partial | No — tracks tasks and budget | Depends on the source | Yes — skills, behavior, outcomes |
| Live refresh | No — monthly | Yes — for task status | Partial — needs a pipeline | Yes — reads on arrival |
| Every tile drills to the participant | No | No — drills to a task | Partial | Yes |
| Reads qualitative reflections | No | No | No — quantitative only | Yes — themed on arrival |
| Operational + outcome on one record | No | No | No — separate sources | Yes |
| Tracks the same participant across cohorts | No — manual matching | No | Partial — if a pipeline exists | Yes — Persistent Contact ID |
| Alerts fire mid-cycle | No | Yes — on task deadlines | Partial | Yes — on attendance and dosage |
| Rebuilt every reporting cycle | Yes — by hand | No | Often — pipeline upkeep | No — one live source |
| Best audience | Program staff, as a fallback | Project managers | Data and IT teams | Program staff, leadership, funders |
A PMO dashboard answers "are we on track to ship." A program dashboard answers "are participants changing." Both can be useful — this page is about the second one.
We trace each tile to the participant record behind it and rebuild one view live — your program, not a demo account.
A program dashboard is the live, always-on view of whether one program is producing the change it was designed to produce. It draws from the participant record, so every number and narrative on screen reflects current state rather than a snapshot from last quarter. A working program dashboard carries operational health on top, outcomes underneath, and the AI-themed reason from open-ended reflections on the side.
A program management dashboard, in the project-portfolio sense, tracks tasks, milestones, budget, and resource allocation — it answers whether the work is on track to ship. A program dashboard, in the impact and evaluation sense, tracks whether participants changed: skills gained, behaviors adopted, conditions improved. The two share a name but answer different questions for different audiences. This guide is about the second one.
Build a program dashboard in six steps: name the decisions the program manager makes each week, write the logic model and data dictionary, collect primary data clean at source under one participant ID, integrate the systems that already hold session data, read every response on arrival, then assemble the layered view and set it to refresh live. The thresholds that fire alerts are defined before collection starts.
A program-level outcomes dashboard is the layer of a program dashboard that surfaces outcome indicators — skills gained, jobs secured, conditions improved — tied to the participant record. Every aggregate can be filtered by cohort, site, or demographic, and opened to the participant-level data that produced it. Without record-level grounding, an outcomes dashboard becomes a static summary nobody can interrogate.
A program health dashboard is the operational layer of a program dashboard: enrollment, attendance, dosage, drop-off, completion, and alerts. It answers the most basic question — is the program delivering on plan — and it is the foundation the outcome and reporting layers sit on. A program with broken delivery cannot produce outcomes, so the health layer catches the delivery problem before it becomes an outcome problem.
A program evaluation dashboard is the live view of the evidence base a program evaluation interprets. The evaluation produces a periodic written judgment; the dashboard exposes the underlying participant record continuously, so the judgment can be checked and updated. Both pull from the same record — the evaluation is the analytical work, the dashboard is the always-on surface.
Seven program dashboard examples cover most of what a program manager needs: an enrollment and attendance dashboard, a participant progress and at-risk dashboard, an outcome dashboard with pre-post comparison, an engagement and feedback dashboard, a milestone and delivery dashboard, a cohort comparison dashboard, and a program health summary. Each is one view of the same program, drawing from one participant record.
Lead with primary data — intake forms, attendance logs, pre-mid-post surveys, mid-cycle reflections you collect directly — because a program dashboard is mostly a live view of the program's own delivery and outcomes. Integrate secondary data when a learning management system or attendance system already holds session data, or when reporting against a funder's framework. The data dictionary maps the two together.
AI dashboards improve visibility by processing open-ended text — reflections, transcripts, documents — into themes, sentiment, and pattern alerts as it arrives. A traditional dashboard shows that 71 percent passed a credential. An AI dashboard shows, next to that number, that the most-named barrier in mid-cycle reflections shifted from transportation to childcare between cohorts. Oversight scales because the AI layer surfaces what would otherwise sit unread in a thousand free-text fields.
Tableau, Power BI, Looker, and Domo are strong visualization tools, but they sit downstream of a data store that must be populated first. For a program dashboard the upstream work — collecting data on a participant record, linking baseline to outcome by stable ID, theming the narratives — is the harder problem. BI tools render the view once that work is done; they do not produce the participant record on their own.
All three pull from the same participant record. A program evaluation is the periodic analytical work of judging whether the program produced its intended outcomes. A program report is the structured artifact that packages the findings for a specific audience. A program dashboard is the live, continuous view of the same evidence base. Cadence, output, and audience differ; the underlying data is one record per participant.
Sopact holds the participant record and the dashboard layer in one place — the record intake writes to is the record the dashboard reads from. Ratings, narratives, documents, and transcripts feed both the operational and outcome layers, and the AI layer themes the narratives as they arrive. The dashboard updates as records update, with role-based views for program staff, leadership, and funders from one source.
The periodic analytical work of judging whether a program produced its outcomes — what the dashboard exposes live.
The structured document drawn from the same participant record, packaged for a specific audience.
The program theory that defines which outcomes the dashboard is set up to track in the first place.
For programs whose outcomes show up over months, the design pattern the dashboard tracks across cycles.
How outcome findings get communicated — the reporting layer of the program dashboard sits inside this.
The same build method, scoped to impact measurement across programs, portfolios, and funders.
Sixty minutes with someone who builds these for a living. Bring the spreadsheet you refresh monthly, the BI report nobody opens, or the program tile you wish was live. We trace each tile to the participant record behind it, show where primary and secondary data connect through the data dictionary, and rebuild one view live. No slideware, no demo accounts — your program, read live.
No slideware. No demo accounts. Your own records, read live.